java基于线程池和反射机制实现定时任务完整实例

本文实例讲述了java基于线程池和反射机制实现定时任务的方法。分享给大家供大家参考,具体如下:

主要包括如下实现类:

1. Main类:

任务执行的入口:

调用main方法,开始加载任务配置并执行任务

package com.yanek.task;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Main {
 /**
  * @param args
  */
 public static void main(String[] args) {
  ScheduledExecutorService scheduExec = Executors.newScheduledThreadPool(1);
  /*
  TaskModel tm=new TaskModel();
  tm.setClassName("com.yanek.task.TaskA");
  tm.setMethodName("testA");
  tm.setInitialDelay(3);
  tm.setPeriod(5);
  */
  List tasks=XmlReader.getTasks();
  for (int i=0;i<tasks.size();i++)
  {
   TaskModel tm=(TaskModel)tasks.get(i);
   scheduExec.scheduleAtFixedRate(new MyTask(tm),tm.getInitialDelay(), tm.getPeriod(), TimeUnit.SECONDS);
  }
 }
}

2. MyTask 类 实现Runnable接口,在main类中调用

package com.yanek.task;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Date;
public class MyTask implements Runnable {
 private TaskModel taskModel;
 public MyTask() {}
 public MyTask(TaskModel tm) {
  this.taskModel = tm;
 }
 public void run() {
   System.out.println("call at " + (new Date()));
   try {
    Class<?> classType = Class.forName(taskModel.getClassName());
    Method getMethod = classType.getMethod(taskModel.getMethodName());
    getMethod.invoke(classType);
   } catch (SecurityException e) {
    e.printStackTrace();
   } catch (IllegalArgumentException e) {
    e.printStackTrace();
   } catch (ClassNotFoundException e) {
    e.printStackTrace();
   } catch (NoSuchMethodException e) {
    e.printStackTrace();
   } catch (IllegalAccessException e) {
    e.printStackTrace();
   } catch (InvocationTargetException e) {
    e.printStackTrace();
   }
 }
}

3. TaskModel: 对任务类的封装

package com.yanek.task;
public class TaskModel {
 public String getClassName() {
  return className;
 }
 public void setClassName(String className) {
  this.className = className;
 }
 public String getMethodName() {
  return methodName;
 }
 public void setMethodName(String methodName) {
  this.methodName = methodName;
 }
 public long getInitialDelay() {
  return initialDelay;
 }
 public void setInitialDelay(long initialDelay) {
  this.initialDelay = initialDelay;
 }
 public long getPeriod() {
  return period;
 }
 public void setPeriod(long period) {
  this.period = period;
 }
 private String className;
 private String methodName;
 private long initialDelay;
 private long period;
}

4. XmlReader 任务配置解析类

package com.yanek.task;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
public class XmlReader {
 public static void main(String[] args) {
  XmlReader.getTasks();
 }
 public static List getTasks() {
  List tasks = new ArrayList();
  System.out.println("load task config start...");
  String path = "/work/TaskManager/conf/taskconfig.xml";
  File file = new File(path);
  if (file.exists() && !file.isDirectory()) {
   try {
    SAXBuilder sx = new SAXBuilder();
    Document doc = sx.build(file);
    Element rootelement = doc.getRootElement();
     List<Element> childs = rootelement.getChildren();
     for (int i = 0; i < childs.size(); i++) {
      TaskModel tModel = new TaskModel();
      tModel.setClassName(childs.get(i).getChildText("class"));
      System.out.println(childs.get(i).getChildText("class"));
      tModel.setMethodName(childs.get(i).getChildText("method"));
      System.out.println(childs.get(i).getChildText("method"));
      String initialDelay = childs.get(i).getChildText("initialDelay");
      tModel.setInitialDelay((Long.valueOf(initialDelay)));
      System.out.println("距离首次运行还差" + initialDelay + "秒!");
      tModel.setPeriod(Integer.valueOf(childs.get(i).getChildText("period")));
      System.out.println(childs.get(i).getChildText("period"));
      tasks.add(tModel);
    }
   } catch (NumberFormatException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (JDOMException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  } else {
   System.out.println("file no exist!");
  }
  System.out.println("load task config end !");
  return tasks;
 }
}

5. 配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<taskconfig>
  <task>
    <class>com.yanek.task.TaskA</class>
    <method>testA</method>
    <initialDelay>5</initialDelay>
    <period>2</period>
  </task>
  <task>
    <class>com.yanek.task.TaskB</class>
    <method>testB</method>
    <initialDelay>5</initialDelay>
    <period>3</period>
  </task>
  <task>
    <class>com.yanek.task.TaskC</class>
    <method>testC</method>
    <initialDelay>5</initialDelay>
    <period>3</period>
  </task>
</taskconfig>

6. 测试任务类:

TaskA TaskB TaskC其中定义静态方法 ,这些类的静态方法配置在 xml文件中,被调用。

package com.yanek.task;
public class TaskA {
 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println("task a test");
 }
 public static void testA()
 {
  System.out.println("taska testA method call!");
 }
}
package com.yanek.task;
public class TaskB {
 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println("task b test");
 }
 public static void testB()
 {
  System.out.println("TaskB testB method call!");
 }
}
package com.yanek.task;
public class TaskC {
 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println("task c test");
 }
 public static void testC()
 {
  System.out.println("Taskc testC method call!");
 }
} 

希望本文所述对大家Java程序设计有所帮助。

时间: 2015-10-31

Java反射机制及Method.invoke详解

JAVA反射机制 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类:在运行时构造任意一个类的对象:在运行时判断任意一个类所具有的成员变量和方法:在运行时调用任意一个对象的方法:生成动态代理. 1. 得到某个对象的属性 复制代码 代码如下: public Object get

java 利用java反射机制动态加载类的简单实现

如下所示: ////////////////// Load.java package org.bromon.reflect; import java.util.ArrayList; import java.util.List; public class Load implements Operator { @Override public List<?> act(List<?> params) { // TODO Auto-generated method stub List<

JAVA反射机制实例教程

本文以实例形式详细讲述了Java的反射机制,是Java程序设计中重要的技巧.分享给大家供大家参考.具体分析如下: 首先,Reflection是Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说"自审",并能直接操作程序的内部属性.例如,使用它能获得 Java 类中各成员的名称并显示出来. Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性.例如,Pascal.C 或者 C++ 中就没有办法在程序中获得函数

通过java反射机制动态调用某方法的总结(推荐)

如下: public Object invokeMethod(String className, String methodName, Object[] args) throws Exception{ Class ownerClass = Class.forName(className); Object owner = ownerClass.newInstance(); Class[] argsClass = new Class[args.length]; for (int i = 0, j =

Java通过反射机制动态设置对象属性值的方法

/** * MethodName: getReflection<br> * Description:解析respXML 在通过反射设置对象属性值 * User: liqijing * Date:2015-7-19下午12:42:55 * @param clzzName * @param respXML * @return * @throws ClassNotFoundException * @throws DocumentException * @throws IllegalArgumentE

利用java反射机制调用类的私有方法(推荐)

试想一下,如果你可以轻易地调用一个类的私有方法,那么是不是说你的封装都失效了?最近在看java的反射机制,发现居然可以利用java的反射机制去调用其他类的私有方法,至于这能干什么,那就见人见智了.. 我写的一段简易实例代码如下: import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * @author thomaslwq * @version 创建时间:Sep 4, 201

Java反射机制概念、原理与用法总结

本文实例讲述了Java反射机制概念.原理与用法.分享给大家供大家参考,具体如下: 反射机制是什么 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 反射机制能做什么 反射机制主要提供了以下功能: ① 在运行时判断任意一个对象所属的类: ② 在运行时构造任意一个类的对象: ③ 在运行时判断任意一个类所具有的成员变量和方法: ④ 在运行时调用任意一个

Java反射机制的实现详解

很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术. 与反射有关的类包. java.lang.reflect.*;和java.lang.Class; Java中所有类型(包括基本类型)都对应一个Class对象,这个Class就是java.lang.Class.即每一个类型,在Class中都有一个Class对象跟它对应.Class 没有公共构造方法.注意不是没有,是没有公共的. 如何获得Class对象 复制代码 代码如下: .针对每一个对象.getCalss(),

Java的反射机制---动态调用对象的简单方法

唉!我还真是在面试中学习新东东啊,一个公司刚刚给了个测试,不过我很奇怪的是为什么web developer的职位居然考java的反射机制题,不过学习研究一下反射机制对我来说是件好事啦! 先说说什么是java反射机制吧,在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这 种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.主要功能:在运行时判断任意一个对象所属的类:在运行时构造任意一个类的对 象:在运行时判断任意一个

java 利用反射机制,获取实体所有属性和方法,并对属性赋值

一个普通的实体Person: private int id; private String name; private Date createdTime; ... //其它字段 // get set方法 ............... 现在需要把通过webService传过来的实体Person里面的所有字段的null值,换成"" 实现思路: 1.获取实体的所有字段,遍历 2.获取字段类型 3.调用字段的get方法,判断字段值是否为空 4.如果字段值为空,调用字段的set方法,为字段赋值

Java反射机制的学习总结

一.什么是反射机制 简单的来说,反射机制指的是程序在运行时能够获取自身的信息.在java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有信息. 二.哪里用到反射机制 有些时候,我们用过一些知识,但是并不知道它的专业术语是什么,在刚刚学jdbc时用过一行代码, Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成驱动对象实例,并不知道它的具体含义.听了反射机制这节课后,才知道,原来这

Java 反射机制的实例详解

Java 反射机制的实例详解 前言 今天介绍下Java的反射机制,以前我们获取一个类的实例都是使用new一个实例出来.那样太low了,今天跟我一起来学习学习一种更加高大上的方式来实现. 正文 Java反射机制定义 Java反射机制是指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 用一句话总结就是反射可以实现在运行时可以知道任意一个类的属性和方法. 反射

Java反射机制深入理解

Java反射机制深入理解 一.概念 反射就是把Java的各种成分映射成相应的Java类. Class类的构造方法是private,由JVM创建. 反射是java语言的一个特性,它允程序在运行时(注意不是编译的时候)来进行自我检查并且对内部的成员进行操作.例如它允许一个java的类获取他所有的成员变量和方法并且显示出来.Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性.例如,Pascal.C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息.

Java反射机制详解_动力节点Java学院整理

一.先看一下反射的概念: 主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义. 反射是Java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接.但是反射使用不当会成本很高! 看概念很晕的,继续往下看. 二.反射机制的作用: 1.反编译:.class-->.java 2.通过反射机制访问java对象的属性,方法,构造方法等: 这样好像更容易理解一些,下边我们具

JAVA反射机制实例详解

本文实例分析了JAVA反射机制.分享给大家供大家参考,具体如下: 反射,当时经常听他们说,自己也看过一些资料,也可能在设计模式中使用过,但是感觉对它没有一个较深入的了解,这次重新学习了一下,感觉还行吧! 一.先看一下反射的概念: 主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义. 反射是java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接.但是反射使用

Java 反射机制详解及实例

Java 反射机制详解及实例 反射,当时经常听他们说,自己也看过一些资料,也可能在设计模式中使用过,但是感觉对它没有一个较深入的了解,这次重新学习了一下,感觉还行吧!            一,先看一下反射的概念: 主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义. 反射是Java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接.但是反射使用不当会成本很高

Java反射机制的讲解

Java中的反射提供了一种运行期获取对象元信息的手段.即正常方法是通过一个类创建对象,反射方法就是通过一个对象找到一个类的信息. Java的反射机制的实现要借助于4个类:class,Constructor,Field,Method; 其中class代表的时类对 象,Constructor-类的构造器对象,Field-类的属性对象,Method-类的方法对象.通过这四个对象我们可以粗略的看到一个类的各个组成部分. Java反射的作用: 在Java运行时环境中,对于任意一个类,可以知道这个类有哪些属

在实践中了解Java反射机制应用

引言 Java反射机制是一个非常强大的功能,在很多大型项目比如Spring, Mybatis都可以看见反射的身影.通过反射机制我们可以在运行期间获取对象的类型信息,利用这一特性我们可以实现工厂模式和代理模式等设计模式,同时也可以解决Java泛型擦除等令人苦恼的问题.本文我们就从实际应用的角度出发,来应用一下Java的反射机制. 反射基础 p.s: 本文需要读者对反射机制的API有一定程度的了解,如果之前没有接触过的话,建议先看一下官方文档的Quick Start. 在应用反射机制之前,首先我们先

全面了解Java反射机制

什么是反射 反射 (Reflection) 是Java的特征之一,它允许运行中的Java程序获取自身的信息,并且可以操作类或对象的内部属性. 通俗的来讲就是:通过反射机制,可以在运行时获得程序或程序集中每一个类型的成员和成员的信息. 注意这里的重点是:运行时,而不是编译时.我们常规情况下写的对象类型都是在编译期就确定下来的.而Java反射机制可以动态地创建对象并调用其属性,这样创建对象的方式便异常灵活了. 虽然通过反射可以动态的创建对象,增加了灵活性,但也不是什么地方都可用,还要考虑性能.编码量