@PostConstruct

一 @postconstruct介绍

从java
ee5规范开始，servlet增加了两个影响servlet生命周期的注解（annotation）：@postconstruct和@preconstruct。这两个注解被用来修饰一个非静态的void()方法.而且这个方法不能有抛出异常声明。
@postcontruct是spring框架的注解，在方法上加该注解会在项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法。

 

写法有如下两种方式：

 

@postconstruct                                 //方式1
    public void somemethod(){
        ...
    }

    public @postconstruct void somemethod(){        //方式2
        ...  
    }

 

    被@postconstruct修饰的方法会在服务器加载servle的时候运行，并且只会被服务器执行一次。postconstruct在构造函数之后执行,init()方法之前执行。predestroy（）方法在destroy()方法执行执行之后执行

       

 

二  @postconstruct在项目中的用处

1.spring项目加载数据字典
@postconstruct注解的方法在项目启动的时候执行这个方法，也可以理解为在spring容器启动的时候执行，可作为一些数据的常规化加载，比如数据字典之类的。

2.spring项目的定时任务
spring自带的@schedule，没有开关，项目启动总会启动一个线程；
做项目的时候就使用java的timer，这个设置开关即可*的控制，关闭的时候，不会启动线程；
java的timer也需要找到一个启动类，可以放到main函数里面启动，这样的话，代码的耦合性太高了，而使用postconstruct是很干净的。

 3 servlet初始化加载之前处理像加载缓存等。

    用的不多，因为如果初始化之前我们要加载或处理某些玩意完全可以在构造器初始化时就处理了，但这种方法需要自己重写构造器。

 1 package com.whaty.products.whatysns.web.info;  
 2   
 3 import javax.annotation.postconstruct;  
 4 import javax.annotation.resource;  
 5   
 6 import org.springframework.stereotype.service;  
 7 import org.springframework.util.assert;  
 8   
 9 import com.whaty.framework.cache.core.model.cache;  
10 import com.whaty.framework.cache.core.service.cacheservice;  
11 import com.whaty.framework.cache.entitycache.service.entitycachehelper;  
12 import com.whaty.framework.cache.entitycache.service.ientitydaoadapter;  
13   
14 /** 
15  * @author 
16  * @param <key> 
17  * @param <entity> 
18  */  
19 @service("ajaxcacheableservice")  
20 public class ajaxcacheableservice{  
21       
22     @resource(name="cacheservice")  
23     protected cacheservice cacheservice;  
24       
25     protected boolean usereadwriteentitydao = false;  
26     protected boolean usecache = true;  
27     protected int entitycachemaxsize = 1000;  
28     protected int entitycachemaxliveseconds = 3600;  
29     protected cache entitycache;  
30       
31       
32     /** 
33      * 构造方法执行后，初始化， 
34      */  
35     @postconstruct  
36     public void init() {  
37         assert.notnull(cacheservice, "cacheservice must be set!");  
38         getcache();  
39     }  
40   
41     /** 
42      * 获取cache 
43      * @return 
44      */  
45     protected cache getcache() {  
46         if (entitycache == null) {  
47             entitycache = cacheservice.addcache(this.getclass().getname(),entitycachemaxliveseconds);  
48         }  
49         return entitycache;  
50     }  
51       
52     /** 
53      * @param id 
54      * @param usecache 是否使用cache 
55      * @return 
56      */  
57     public object getcache(string id) {  
58         string strid = string.valueof(id);  
59         object o = entitycache.get(strid);  
60         return  o;  
61     }  
62       
63     public object putcache(int ttlseconds,string cacheid,object value) {  
64         string strid = string.valueof(cacheid);  
65         object o = entitycache.get(strid);  
66         if (o != null) {  
67             return  o;  
68         } else {  
69             entitycache.put(strid, value, ttlseconds);  
70             return value;  
71         }  
72     }  
73       
74 }

三 工程

1 <!-- @postconstruct和@predestroy注解 -->
2   <servlet>
3     <servlet-name>annotationservlet</servlet-name>
4     <servlet-class>com.servlet.annotationservlet</servlet-class>
5   </servlet>
6 <servlet-mapping>
7     <servlet-name>annotationservlet</servlet-name>
8     <url-pattern>/servlet/annotationservlet</url-pattern>
9   </servlet-mapping>

 1 package com.servlet;
 2 
 3 import java.io.ioexception;
 4 import java.io.printwriter;
 5 import java.sql.time;
 6 import java.text.simpledateformat;
 7 import java.util.date;
 8 
 9 import javax.annotation.postconstruct;
10 import javax.annotation.predestroy;
11 import javax.servlet.servletexception;
12 import javax.servlet.http.httpservlet;
13 import javax.servlet.http.httpservletrequest;
14 import javax.servlet.http.httpservletresponse;
15 
16 public class annotationservlet extends httpservlet {
17     simpledateformat df = new simpledateformat("hh:mm:ss.sss");//设置日期格式,精确到毫秒
18     
19     public annotationservlet(){
20         system.out.println("时间："+df.format(new date())+"执行构造函数...");
21     }
22     
23     public void destroy() {
24         this.log("时间："+df.format(new date())+"执行destroy()方法...");
25         //super.destroy(); // just puts "destroy" string in log
26         // put your code here
27     }
28 
29     @postconstruct
30     public void somemethod(){
31         //this.log("执行@postconstruct修饰的somemethod()方法...");//注意：这样会出错
32         system.out.println("时间："+df.format(new date())+"执行@postconstruct修饰的somemethod()方法...");
33     }
34     
35     @predestroy
36     public void othermethod(){
37         system.out.println("时间："+df.format(new date())+"执行@predestroy修饰的othermethod()方法...");
38     }
39     
40     public void doget(httpservletrequest request, httpservletresponse response)
41             throws servletexception, ioexception {
42         this.log("时间："+df.format(new date())+"执行doget()方法...");
43     }
44 
45     public void init() throws servletexception {
46         // put your code here
47         this.log("时间："+df.format(new date())+"执行init()方法...");
48     }
49     
50     protected void service(httpservletrequest request, httpservletresponse response)
51                throws servletexception, ioexception{
52         this.log("时间："+df.format(new date())+"执行service()方法...");
53         super.service(request, response);
54     }
55 
56 }

 

四 spring中constructor、@autowired、@postconstruct的顺序

    constructor >> @autowired >> @postconstruct

    要将对象p注入到对象a，那么首先就必须得生成对象p与对象a，才能执行注入。

    所以，如果一个类a中有个成员变量p被@autowired注解，那么@autowired注入是发生在a的构造方法执行完之后的。

 

     如果想在生成对象时候完成某些初始化操作，而偏偏这些初始化操作又依赖于依赖注入，那么就无法在构造函数中实现。

为此，可以使用@postconstruct注解一个方法来完成初始化，@postconstruct注解的方法将会在依赖注入完成后被自动调用。