• 自己写的关于生产者与消费者模式，还有定时任务的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-------------
  • 相关阅读:
    MFC 将文件拖进对话框获得文件信息
    微软历史最高市值是多少？
    ZooKeeper的学习与应用
    OutputCache祥解
    本人的微博转移
    java list三种遍历方法性能比較
    VS2010旗舰版安装图解
    SSL协议具体解释
    freemarker字符串拼接
    ［java web 入门］（一）MyEclipse &amp; HelloWorld 记录
  • 原文地址：https://www.cnblogs.com/jpfss/p/9447427.html
Copyright © 2020-2023  润新知