自己写的关于生产者与消费者模式，还有定时任务的demo

为了加深对生产者消费者模式的理解，特意写了这个demo，里面还包含了一个自己写的定时任务。代码下载地址：http://download.csdn.net/detail/li_yan_fei/9811572

是个maven项目，只用了spring框架。


学到的内容有3个

第一：加深了对生产者消费者模式的理解

第二：java Object 的wait（） timeout数值如果等于0，则会造成线程一直等待下去，除非被notify唤醒

第三：java中main函数主线程死掉不会影响其他线程的正常执行（除了守护线程）。因为main函数主线程和其他非守护线程是一样的。


代码：

1.一个实现了按时间排序的队列

  1. package com.lyf.task;
  2.  
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6.  
  7. import org.apache.commons.beanutils.BeanUtils;
  8.  
  9. import com.lyf.bean.TaskInfo;
  10.  
  11. /**
  12.  * @ClassName: TaskStack
  13.  * @Description: 实现了一个按照时间顺序排列的队列
  14.  * @author yanfei.li
  15.  * @date 2017年4月10日 下午1:53:49
  16.  * @Company:
  17.  */
  18. public class TaskStack {
  19.  
  20. 	private List<TaskInfo> queue = new ArrayList<TaskInfo>();
  21.  
  22. 	public TaskStack() {
  23. 	}
  24.  
  25. 	/**
  26. 	 * 功能描述: 往队列里塞任务
  27. 	 * @Title: push
  28. 	 * @author yanfei.li
  29. 	 * @date 2017年4月11日 上午11:41:50 
  30. 	 * @param taskInfo 
  31. 	 * @return void    
  32. 	 * @throws
  33. 	 */
  34. 	public synchronized void push(TaskInfo taskInfo) {
  35.  
  36. 		// 如果是空队列，直接将任务放进去就可以了
  37. 		if (this.queue.isEmpty()) {
  38. 			this.queue.add(taskInfo);
  39. 			// 唤醒正在调用pop的消费者线程
  40. 			this.notify();
  41. 			return;
  42. 		}
  43. 		// 如果队列不是空的，就要比较执行时间了，根据执行时间排序
  44. 		for (int index = 0; index < this.queue.size(); index++) {
  45. 			TaskInfo info = this.queue.get(index);
  46. 			if (info.getRunTime() > taskInfo.getRunTime()) {
  47. 				this.queue.add(index, info);
  48. 				this.notify();
  49. 				return;
  50. 			}
  51. 		}
  52. 	}
  53.  
  54. 	/**
  55. 	 * 功能描述: 从队列里取任务
  56. 	 * @Title: pop
  57. 	 * @author yanfei.li
  58. 	 * @date 2017年4月11日 上午11:41:28 
  59. 	 * @return TaskInfo    
  60. 	 * @throws
  61. 	 */
  62. 	public synchronized TaskInfo pop() {
  63.  
  64. 		// 如果队列里没有，就释放锁，等待唤醒
  65. 		if (this.queue.isEmpty()) {
  66. 			try {
  67. 				this.wait();
  68. 			} catch (InterruptedException e) {
  69. 				e.printStackTrace();
  70. 			}
  71. 		}
  72.  
  73. 		while (true) {
  74. 			TaskInfo taskInfo = this.queue.get(0);
  75. 			Long now = System.currentTimeMillis();
  76. 			if (now >= taskInfo.getRunTime()) {// 如果取出的任务到了执行的时间了，就返回该任务并且从队列中移除此任务。这里一定要注意了 判断条件一定要有=号，因为很可能出现相等的情况，如果进入了else中，就会造成wait(0).如果没有notify就一直等下去了
  77. 				this.queue.remove(0);
  78. 				return taskInfo;
  79. 			} else {
  80. 				try {
  81. 					System.out.println("pop--------" + (taskInfo.getRunTime() - now));
  82. 					this.wait(taskInfo.getRunTime() - now);
  83. 				} catch (InterruptedException e) {
  84. 					e.printStackTrace();
  85. 				}
  86. 			}
  87. 		}
  88. 	}
  89.  
  90. 	/**
  91. 	 * 功能描述: 从队列里移除任务
  92. 	 * @Title: remove
  93. 	 * @author yanfei.li
  94. 	 * @date 2017年4月11日 上午11:41:06 
  95. 	 * @param taskInfo 
  96. 	 * @return void    
  97. 	 * @throws
  98. 	 */
  99. 	public synchronized void remove(TaskInfo taskInfo) {
  100. 		this.queue.remove(taskInfo);
  101. 	}
  102.  
  103. 	/**
  104. 	 * 功能描述: 返回队列里所有的任务
  105. 	 * @Title: getAll
  106. 	 * @author yanfei.li
  107. 	 * @date 2017年4月11日 上午11:40:36 
  108. 	 * @return List<TaskInfo>    
  109. 	 * @throws
  110. 	 */
  111. 	public synchronized List<TaskInfo> getAll() {
  112. 		List<TaskInfo> retList = new ArrayList<TaskInfo>();
  113. 		for (TaskInfo taskInfo : this.queue) {
  114. 			try {
  115. 				TaskInfo retTask = new TaskInfo();
  116. 				BeanUtils.copyProperties(retTask, taskInfo);
  117. 				retList.add(retTask);
  118. 			} catch (IllegalAccessException e) {
  119. 				// TODO Auto-generated catch block
  120. 				e.printStackTrace();
  121. 			} catch (InvocationTargetException e) {
  122. 				// TODO Auto-generated catch block
  123. 				e.printStackTrace();
  124. 			}
  125.  
  126. 		}
  127. 		return retList;
  128. 	}
  129. }

2.消费者 

  1. package com.lyf.task;
  2.  
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5.  
  6. import com.lyf.bean.TaskInfo;
  7. import com.lyf.util.SpringContextUtils;
  8.  
  9. /**
  10.  * @ClassName: TaskExecutor 
  11.  * @Description: 任务执行器，相当于消费者
  12.  * @author yanfei.li 
  13.  * @date 2017年4月10日 下午1:52:00 
  14.  * @Company: 
  15.  *
  16.  */
  17. public class TaskExecutor implements Runnable {
  18.  
  19. 	private TaskStack taskStack = null;//任务队列
  20. 	private ExecutorService fixedThreadPool = null;//线程执行池，选择的固定线程池大小，由sping初始化
  21. 	
  22. 	public TaskExecutor(TaskStack taskStack,int poolSize) {
  23. 		this.taskStack = taskStack;
  24. 		this.fixedThreadPool = Executors.newFixedThreadPool(poolSize);
  25. 	}
  26. 	
  27. 	public void run() {
  28. 		
  29. 		while(true){
  30. 			try {
  31. 				//获取当前要执行的任务
  32. 				TaskInfo taskInfo = taskStack.pop();
  33. 				//解析taskinfo信息，获取真正执行的task
  34. 				TaskInterface instance = (TaskInterface)SpringContextUtils.getBean(taskInfo.getApi());
  35. 				//将任务信息，传递给将要执行的task
  36. 				instance.setTaskInfo(taskInfo);
  37. 				//将任务放到线程池中执行
  38. 				this.fixedThreadPool.submit(instance);
  39. 				//如果是周期性的任务，则计算出下次执行时间，然后放到队列中
  40. 				if(instance.hasNext()){
  41. 					this.taskStack.push(instance.next());
  42. 				}
  43. 			} catch (Exception e) {
  44. 				e.printStackTrace();
  45. 			}
  46. 		}
  47.  
  48. 	}
  49.  
  50. }

3.任务bean 

  1. package com.lyf.bean;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * @ClassName: TaskInfo
  7.  * @Description: 任务实体
  8.  * @author yanfei.li
  9.  * @date 2017年4月10日 下午1:54:58
  10.  * @Company:
  11.  *
  12.  */
  13. public class TaskInfo implements Serializable {
  14.  
  15. 	private static final long serialVersionUID = 8609311967819063807L;
  16.  
  17. 	private String id;// 任务id
  18.  
  19. 	private String type;// 任务类型
  20.  
  21. 	private String runAt;// 执行时间规则
  22.  
  23. 	private String cron;// cron表达式
  24.  
  25. 	private long runTime;// 执行时间
  26.  
  27. 	private String api;// 执行接口
  28.  
  29. 	private Object[] params;// 任务参数
  30.  
  31. 	public String getId() {
  32. 		return id;
  33. 	}
  34.  
  35. 	public void setId(String id) {
  36. 		this.id = id;
  37. 	}
  38.  
  39. 	public String getType() {
  40. 		return type;
  41. 	}
  42.  
  43. 	public void setType(String type) {
  44. 		this.type = type;
  45. 	}
  46.  
  47. 	public String getRunAt() {
  48. 		return runAt;
  49. 	}
  50.  
  51. 	public void setRunAt(String runAt) {
  52. 		this.runAt = runAt;
  53. 	}
  54.  
  55. 	public String getCron() {
  56. 		return cron;
  57. 	}
  58.  
  59. 	public void setCron(String cron) {
  60. 		this.cron = cron;
  61. 	}
  62.  
  63. 	public long getRunTime() {
  64. 		return runTime;
  65. 	}
  66.  
  67. 	public void setRunTime(long runTime) {
  68. 		this.runTime = runTime;
  69. 	}
  70.  
  71. 	public String getApi() {
  72. 		return api;
  73. 	}
  74.  
  75. 	public void setApi(String api) {
  76. 		this.api = api;
  77. 	}
  78.  
  79. 	public Object[] getParams() {
  80. 		return params;
  81. 	}
  82.  
  83. 	public void setParams(Object[] params) {
  84. 		this.params = params;
  85. 	}
  86.  
  87. }

4.任务接口 

  1. package com.lyf.task;
  2.  
  3. import com.lyf.bean.TaskInfo;
  4.  
  5. /**
  6.  * @ClassName: TaskInterface 
  7.  * @Description: TODO
  8.  * @author yanfei.li 
  9.  * @date 2017年4月11日 下午12:00:10 
  10.  * @Company: 
  11.  *
  12.  */
  13. public interface TaskInterface extends Runnable {
  14.  
  15. 	/**
  16. 	 * 功能描述: 设置任务
  17. 	 * @Title: setTaskInfo
  18. 	 * @author yanfei.li
  19. 	 * @date 2017年4月11日 下午12:03:28 
  20. 	 * @param taskInfo 
  21. 	 * @return void    
  22. 	 * @throws
  23. 	 */
  24. 	public void setTaskInfo(TaskInfo taskInfo);
  25. 	/**
  26. 	 * 功能描述: 判断此任务是否还需要执行，针对的是循环性的任务
  27. 	 * @Title: hasNext
  28. 	 * @author yanfei.li
  29. 	 * @date 2017年4月11日 下午12:02:14 
  30. 	 * @return boolean    
  31. 	 * @throws
  32. 	 */
  33. 	public boolean hasNext();
  34. 	/**
  35. 	 * 功能描述: 返回下次要执行的任务
  36. 	 * @Title: next
  37. 	 * @author yanfei.li
  38. 	 * @date 2017年4月11日 下午12:02:18 
  39. 	 * @return TaskInfo    
  40. 	 * @throws
  41. 	 */
  42. 	public TaskInfo next();
  43. }
5.实现了任务接口的任务抽象模板类

  1. package com.lyf.task;
  2.  
  3. import com.lyf.bean.TaskInfo;
  4. import com.lyf.util.SpringCronResolveUtil;
  5.  
  6. /**
  7.  * @ClassName: TaskInstance 
  8.  * @Description: 任务执行的模板类
  9.  * @author yanfei.li 
  10.  * @date 2017年4月11日 下午2:47:57 
  11.  * @Company: 
  12.  *
  13.  */
  14. public abstract class TaskInstance implements TaskInterface {
  15.  
  16. 	protected TaskInfo taskInfo;
  17. 	
  18. 	
  19. 	public void run() {
  20. 		
  21. 		try {
  22. 			this.before();
  23. 			this.execute();
  24. 			this.after();
  25. 		} catch (Exception e) {
  26. 			// TODO Auto-generated catch block
  27. 			e.printStackTrace();
  28. 		} finally {
  29. 			//如果要记录日志什么的，可以放到这里
  30. 		}
  31.  
  32. 	}
  33. 	
  34. 	/**
  35. 	 * 功能描述: 任务执行前执行的方法，比如做一些初始化工作
  36. 	 * @Title: before
  37. 	 * @author yanfei.li
  38. 	 * @date 2017年4月11日 下午2:50:43  
  39. 	 * @return void    
  40. 	 * @throws
  41. 	 */
  42. 	protected abstract void before() throws Exception;
  43. 	
  44. 	/**
  45. 	 * 功能描述: 任务执行的具体方法
  46. 	 * @Title: excute
  47. 	 * @author yanfei.li
  48. 	 * @date 2017年4月11日 下午2:51:25  
  49. 	 * @return void    
  50. 	 * @throws
  51. 	 */
  52. 	protected abstract void execute() throws Exception;
  53. 	
  54. 	/**
  55. 	 * 功能描述: 任务执行完后执行的方法
  56. 	 * @Title: after
  57. 	 * @author yanfei.li
  58. 	 * @date 2017年4月11日 下午2:51:41  
  59. 	 * @return void    
  60. 	 * @throws
  61. 	 */
  62. 	protected abstract void after() throws Exception;
  63. 	
  64. 	
  65. 	public void setTaskInfo(TaskInfo taskInfo) {
  66. 		this.taskInfo = taskInfo;
  67. 	}
  68.  
  69. 	public boolean hasNext() {
  70. 		if (this.taskInfo != null && !this.taskInfo.getRunAt().equals("now")) {
  71. 			return true;
  72. 		}
  73. 		return false;
  74. 	}
  75.  
  76. 	public TaskInfo next() {
  77. 		if (this.taskInfo != null) {
  78. 			this.taskInfo.setRunTime(
  79. 					SpringCronResolveUtil.nextExecutionTime(this.taskInfo.getCron(), this.taskInfo.getRunTime()));
  80. 			System.out.println("next===========" + (taskInfo.getRunTime() - System.currentTimeMillis()));
  81. 			return this.taskInfo;
  82. 		}
  83. 		return null;
  84. 	}
  85.  
  86. }

6.具体任务实现类 

  1. package com.lyf.task;
  2.  
  3. import org.springframework.context.annotation.Scope;
  4. import org.springframework.stereotype.Service;
  5.  
  6. @Service("MyTask")
  7. @Scope("prototype")
  8. public class MyTask extends TaskInstance {
  9.  
  10. 	@Override
  11. 	protected void before() throws Exception {
  12. 		System.out.println("MyTask--------------before-------------");
  13.  
  14. 	}
  15.  
  16. 	@Override
  17. 	protected void execute() throws Exception {
  18. 		System.out.println("MyTask--------------execute-------------");
  19.  
  20. 	}
  21.  
  22. 	@Override
  23. 	protected void after() throws Exception {
  24. 		System.out.println("MyTask--------------after-------------");
  25. 	}
  26.  
  27. }

7.任务service 

  1. package com.lyf.task;
  2.  
  3. import com.lyf.bean.TaskInfo;
  4.  
  5. public interface TaskService {
  6.  
  7. 	public void startTask(TaskInfo task);
  8. }


8.实现类


  1. package com.lyf.task;
  2.  
  3. import com.lyf.bean.TaskInfo;
  4. import com.lyf.util.SpringCronResolveUtil;
  5.  
  6. public class TaskServiceImpl implements TaskService{
  7.  
  8. 	private TaskStack taskStack = null;
  9. 	private TaskExecutor executor = null;
  10. 	
  11. 	public TaskServiceImpl(Integer poolSize) {
  12. 		this.taskStack = new TaskStack();
  13. 		if(poolSize != null){
  14. 			executor = new TaskExecutor(this.taskStack, poolSize);
  15. 			new Thread(executor).start();
  16. 		}
  17. 		this.init();
  18. 	}
  19. 	
  20. 	private void init(){
  21. 		//做一些其他的初始化工作
  22. 	}
  23.  
  24. 	public void startTask(TaskInfo task) {
  25. 		
  26. 		if (task == null) {
  27. 			return;
  28. 		}
  29. 		
  30. 		//首次执行，设置runTime
  31. 		if (task.getRunAt().equals("now")) {
  32. 			task.setRunTime(System.currentTimeMillis() - 1);
  33. 		} else {
  34. 			if (task.getCron() == null || "".equals(task.getCron().trim())) {
  35. 				return;
  36. 			}
  37. 			task.setRunTime(SpringCronResolveUtil.nextExecutionTime(task.getCron()));
  38. 		}
  39. 		this.taskStack.push(task);
  40. 	}
  41. 	
  42. }


9.从spring容器中获取bean的工具类（在多线程环境下使用spring注解无法注入bean，所以需要手动获取bean）



  1. package com.lyf.util;
  2.  
  3. import org.springframework.beans.BeansException;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.ApplicationContextAware;
  6.  
  7. public class SpringContextUtils implements ApplicationContextAware {
  8.  
  9. 	private static ApplicationContext applicationContext = null;
  10. 	/**
  11. 	 * 当继承了ApplicationContextAware类之后，那么程序在调用 
  12.      * getBean(String)的时候会自动调用该方法，不用自己操作  
  13. 	 */
  14. 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  15. 		SpringContextUtils.applicationContext = applicationContext;
  16. 	}
  17. 	
  18. 	public static ApplicationContext getApplicationContext(){
  19. 		return SpringContextUtils.applicationContext;
  20. 	}
  21. 	/**
  22. 	 * 功能描述: 根据name从spring容器中返回bean
  23. 	 * @Title: getBean
  24. 	 * @author yanfei.li
  25. 	 * @date 2017年4月11日 下午1:47:17 
  26. 	 * @param name
  27. 	 * @throws BeansException 
  28. 	 * @return Object    
  29. 	 */
  30. 	public static Object getBean(String name)throws BeansException{
  31. 		return applicationContext.getBean(name);
  32. 	}
  33. 	/**
  34. 	 * 功能描述: 根据name和类型从spring容器中返回bean
  35. 	 * @Title: getBean
  36. 	 * @author yanfei.li
  37. 	 * @date 2017年4月11日 下午1:46:46 
  38. 	 * @param name
  39. 	 * @param requireType
  40. 	 * @throws BeansException 
  41. 	 * @return Object    
  42. 	 */
  43. 	public static <T> Object getBean(String name,Class<T> requireType)throws BeansException{
  44. 		return applicationContext.getBean(name,requireType);
  45. 	}
  46. 	
  47. }

10.解析cron表达式的util（表达式只能是以空格分割的包含6个字符的字符串，不然会报错）


  1. package com.lyf.util;
  2.  
  3. import java.util.Date;
  4.  
  5. import org.springframework.scheduling.support.CronSequenceGenerator;
  6.  
  7. /**
  8.  * @ClassName: SpringCronResolveUtil 
  9.  * @Description: 解析cron字符串的工具类
  10.  * @author yanfei.li 
  11.  * @date 2017年4月11日 下午2:59:44 
  12.  * @Company: 
  13.  *
  14.  */
  15. public class SpringCronResolveUtil {
  16.  
  17. 	/**
  18. 	 * 功能描述: 根据当前时间计算并返回下次执行时间
  19. 	 * @Title: nextExecutionTime
  20. 	 * @author yanfei.li
  21. 	 * @date 2017年4月11日 下午3:00:56 
  22. 	 * @param cron 表达式字符串,包含6个以空格分开的字符
  23. 	 * @return long    
  24. 	 * @throws
  25. 	 */
  26. 	public static long nextExecutionTime(String cron){
  27. 		CronSequenceGenerator cronSequenceGenerator = new CronSequenceGenerator(cron);
  28. 		Date lastTime = new Date();
  29. 		Date nexDate = cronSequenceGenerator.next(lastTime);
  30. 		
  31. 		return nexDate.getTime();
  32. 		
  33. 	}
  34. 	
  35. 	/**
  36. 	 * 功能描述: 根据最后一次执行时间计算并返回下次执行时间
  37. 	 * @Title: nextExecutionTime
  38. 	 * @author yanfei.li
  39. 	 * @date 2017年4月11日 下午3:00:23 
  40. 	 * @param cron 表达式字符串，一定要是包含6个以空格分离的字符
  41. 	 * @param lastTime 最近的执行时间
  42. 	 * @return long    
  43. 	 * @throws
  44. 	 */
  45. 	public static long nextExecutionTime(String cron,long lastTime) {
  46. 		Date date = new Date(lastTime);
  47. 		CronSequenceGenerator cronSequenceGenerator = new CronSequenceGenerator(cron);
  48. 		Date nexDate = cronSequenceGenerator.next(date);
  49. 		return nexDate.getTime();
  50. 	}
  51. 	
  52. 	public static void main(String[] args) {
  53. 		String cron = "0/10 * * * * ? ";
  54. 		System.out.println("当前时间:" + new Date().getTime()); 
  55. 		System.out.println("下一次时间:" + nextExecutionTime(cron));
  56. 	}
  57. }


11.测试


  1. package com.lyf.producerandconsumer;
  2.  
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5.  
  6. import com.lyf.bean.TaskInfo;
  7. import com.lyf.task.TaskService;
  8. import com.lyf.util.SpringContextUtils;
  9.  
  10. /**
  11.  * @ClassName: TestMain 
  12.  * @Description: 测试
  13.  * @author yanfei.li 
  14.  * @date 2017年4月11日 下午6:20:30 
  15.  * @Company: 
  16.  *
  17.  */
  18. public class TestMain {
  19.  
  20. 	public static void main(String[] args) throws InterruptedException {
  21. 		System.out.println("---------------");
  22. 		ApplicationContext ac = new ClassPathXmlApplicationContext("com/lyf/task/local-spring.xml");
  23. 		TaskInfo taskInfo = new TaskInfo();
  24. 		taskInfo.setApi("MyTask");
  25. 		taskInfo.setRunAt("some");
  26. 		taskInfo.setCron("0/10 * * * * ?");//每隔10秒执行一次
  27. 		taskInfo.setType("me");
  28. 		System.out.println("++++++++++++++++" + ac);
  29. 		TaskService taskService = (TaskService) SpringContextUtils.getBean("TaskService");
  30. 		taskService.startTask(taskInfo);
  31. 		
  32. 		System.out.println("===========" + taskService);
  33. 		
  34. 		//主线程的死掉，不会影响其他线程的继续执行，除非是守护线程。
  35.  
  36. 	}
  37.  
  38. }


12.pom.xml



  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.  
  5.   <groupId>com.lyf</groupId>
  6.   <artifactId>producerandconsumer</artifactId>
  7.   <version>0.0.1-SNAPSHOT</version>
  8.   <packaging>jar</packaging>
  9.  
  10.   <name>producerandconsumer</name>
  11.   <url>http://maven.apache.org</url>
  12.  
  13.   <properties>
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15.   </properties>
  16.  
  17.   <dependencies>
  18.     <dependency>
  19.       <groupId>junit</groupId>
  20.       <artifactId>junit</artifactId>
  21.       <version>3.8.1</version>
  22.       <scope>test</scope>
  23.     </dependency>
  24.     
  25.     <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
  26. 		<dependency>
  27. 			<groupId>commons-beanutils</groupId>
  28. 			<artifactId>commons-beanutils</artifactId>
  29. 			<version>1.8.3</version>
  30. 		</dependency>
  31.     		<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
  32. 		<dependency>
  33. 			<groupId>org.springframework</groupId>
  34. 			<artifactId>spring-aop</artifactId>
  35. 			<version>4.0.4.RELEASE</version>
  36. 		</dependency>
  37.  
  38. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
  39. 		<dependency>
  40. 			<groupId>org.springframework</groupId>
  41. 			<artifactId>spring-beans</artifactId>
  42. 			<version>4.0.4.RELEASE</version>
  43. 		</dependency>
  44.  
  45.  
  46. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
  47. 		<dependency>
  48. 			<groupId>org.springframework</groupId>
  49. 			<artifactId>spring-context</artifactId>
  50. 			<version>4.0.4.RELEASE</version>
  51. 		</dependency>
  52.  
  53. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
  54. 		<dependency>
  55. 			<groupId>org.springframework</groupId>
  56. 			<artifactId>spring-core</artifactId>
  57. 			<version>4.0.4.RELEASE</version>
  58. 		</dependency>
  59. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
  60. 		<dependency>
  61. 			<groupId>org.springframework</groupId>
  62. 			<artifactId>spring-tx</artifactId>
  63. 			<version>4.0.4.RELEASE</version>
  64. 		</dependency>
  65.  
  66. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
  67. 		<dependency>
  68. 			<groupId>org.springframework</groupId>
  69. 			<artifactId>spring-web</artifactId>
  70. 			<version>4.0.4.RELEASE</version>
  71. 		</dependency>
  72. 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
  73. 		<dependency>
  74. 			<groupId>org.springframework</groupId>
  75. 			<artifactId>spring-expression</artifactId>
  76. 			<version>4.0.4.RELEASE</version>
  77. 		</dependency>
  78. 		<!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
  79. 		<dependency>
  80. 			<groupId>aopalliance</groupId>
  81. 			<artifactId>aopalliance</artifactId>
  82. 			<version>1.0</version>
  83. 		</dependency>
  84.  
  85. 		<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
  86. 		<dependency>
  87. 			<groupId>org.aspectj</groupId>
  88. 			<artifactId>aspectjweaver</artifactId>
  89. 			<version>1.8.0</version>
  90. 		</dependency>
  91. 				<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
  92. 		<dependency>
  93. 			<groupId>commons-logging</groupId>
  94. 			<artifactId>commons-logging</artifactId>
  95. 			<version>1.1.3</version>
  96. 		</dependency>
  97.   </dependencies>
  98. </project>

13.spring.xml




  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
  4. 	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  5. 	xmlns:aop="http://www.springframework.org/schema/aop"
  6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  8. 		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
  9. 		http://www.springframework.org/schema/aop
  10.                      http://www.springframework.org/schema/aop/spring-aop.xsd ">
  11.  
  12. 	<!-- 启动注解扫描 -->
  13. 	<context:annotation-config/>
  14. 	<!-- 指定扫描的路径 -->
  15. 	<context:component-scan base-package="com.lyf.*" > 
  16. 		<!-- 不对controller的注解 做处理，过滤掉，是为了和springmvc整合时，防止重复扫描，造成bean初始化2次-->
  17. 		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  18. 	</context:component-scan>
  19.     
  20.     <bean id="springUtils" class="com.lyf.util.SpringContextUtils"/>
  21.     
  22. 	<bean name="TaskService" class="com.lyf.task.TaskServiceImpl">
  23. 		<constructor-arg>
  24. 			<value>5</value>
  25. 		</constructor-arg>
  26. 	</bean>
  27.  
  28.  
  29. </beans>


14.测试结果（每隔十秒执行一次，只贴出了部分打印数据）


  1. ++++++++++++++++org.springframework.context.support.ClassPathXmlApplicationContext@23e352bf: startup date [Wed Apr 12 11:44:46 GMT+08:00 2017]; root of context hierarchy
  2. ===========com.lyf.task.TaskServiceImpl@2f54745e
  3. pop--------3621
  4. MyTask--------------before-------------
  5. MyTask--------------execute-------------
  6. MyTask--------------after-------------
  7. next===========9997
  8. pop--------9997
  9. MyTask--------------before-------------
  10. MyTask--------------execute-------------
  11. MyTask--------------after-------------
  12. next===========9999
  13. pop--------9999
  14. MyTask--------------before-------------
  15. MyTask--------------execute-------------
  16. MyTask--------------after-------------



posted @ 2018-08-09 10:35  星朝  阅读(315)  评论(0)  编辑  收藏  举报