java 类的方法会自动运行吗,服务起步自动运行类方法

服务启动自动运行类方法

利用ServletContextListener类来实现：

package com.autorun;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

import javax.servlet.http.HttpServlet;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

@SuppressWarnings("serial")

public class AutoRun extends HttpServlet implements ServletContextListener {

/**

* 服务器停止前自动执行

*/

@Override

public void contextDestroyed(ServletContextEvent arg0) {

DeleteFile();

}

/**

* 服务器启动后自动运行

*/

@Override

public void contextInitialized(ServletContextEvent arg0) {

WriteFile();

ApplicationContext app = new ClassPathXmlApplicationContext("classpath*:spring/*.xml");

//使用线程池启动一个线程进行轮询队列

MasterGlobalResource.getExecutor().execute((JobService)app.getBean("jobService"));

}

public void WriteFile() {

try {

System.out.println("write");

FileWriter fw = new FileWriter("c:/WriteData.txt");

// 将字符串写入文件

fw.write("Hello World！");

fw.write("Hello Everyone!");

fw.close();

} catch (IOException e) {

}

}

public void DeleteFile() {

File f = new File("c:/WriteData.txt");

// 检查文件是否存在，如果存在，直接删除文件

if (f.exists()) {

f.delete();

}

}

}

web.xml配置监听：

com.autorun.AutoRun

MasterGlobalResource类如下：

package com.autorun;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public  class MasterGlobalResource {

//线程池

private static ThreadPoolExecutor                                      executor                 = new ThreadPoolExecutor(

10,

10,

0L,

TimeUnit.MILLISECONDS,

new LinkedBlockingQueue(),

new ThreadPoolExecutor.DiscardPolicy());

//队列

private static LinkedBlockingQueue             waitingJobQueue          = new LinkedBlockingQueue();

public static ThreadPoolExecutor getExecutor() {

return executor;

}

public static LinkedBlockingQueue getWaitingJobQueue()

{

return waitingJobQueue;

}

public static void setWaitingJobQueue(ZephyrJobWrapper job)

{

waitingJobQueue.add(job);

}

}

用来轮询的com.autorun.JobService类如下：

package com.autorun;

public class JobService implements Runnable {

public MasterGlobalResource masterGlobalResource;

@Override

public void run() {

while(true)

{

System.out.println("size="+masterGlobalResource.getWaitingJobQueue().size());

for(ZephyrJobWrapper job:masterGlobalResource.getWaitingJobQueue())

{

System.out.println(job.getJobId()+"  "+job.getJobName());

}

try {

Thread.sleep(1000);//一秒轮询一次

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

写一个controller用来向队列waitingJobQueue写入数据(主要代码如下)：

public MasterGlobalResource masterGlobalResource;

//向队列写入10个对象

for(int i=0;i<10;i++)

{

ZephyrJobWrapper job=new ZephyrJobWrapper();

job.setJobId(String.valueOf(i));

job.setJobName(String.valueOf(i));

masterGlobalResource.setWaitingJobQueue(job);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

启动服务后，会自动启动轮询队列waitingJobQueue的线程，此时执行 controller,打印结果如下;

//启动服务由于还没向队列写数据得到的队列长度为0

size=0

size=0

.....

//调用了controller,向队列写入了数据，队列程度为10

size=10

0  0

1  1

2  2

3  3

4  4

5  5

6  6

7  7

8  8

9  9

......

注意：使用 main函数来向队列写入数据 不可行，轮询得到的结果任然是size=0....

public static void main(String[] args) {

ApplicationContext app=new ClassPathXmlApplicationContext("classpath*:spring/*.xml");

System.out.println("begin");

MasterGlobalResource res=(MasterGlobalResource)app.getBean("masterGlobalResource");

for(int i=0;i<10;i++)

{

ZephyrJobWrapper job=new ZephyrJobWrapper();

job.setJobId(String.valueOf(i));

job.setJobName(String.valueOf(i));

res.setWaitingJobQueue(job);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println("end");

}