@PostConstruct引出的servlet加载顺序和类的加载顺序

从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。写法有如下两种方式：

@PostConstruct
public void someMethod(){}

或者

public @PostConstruct void someMethod(){}

被PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行，init（）方法之前执行。PreDestroy（）方法在destroy（）方法知性之后执行；
servlet执行流程如图：

另外，spring中Constructor、@Autowired、@PostConstruct的顺序如下：
其实从依赖注入的字面意思就可以知道，要将对象p注入到对象a，那么首先就必须得生成对象a和对象p，才能执行注入。所以，如果一个类A中有个成员变量p被@Autowried注解，那么@Autowired注入是发生在A的构造方法执行完之后的。

如果想在生成对象时完成某些初始化操作，而偏偏这些初始化操作又依赖于依赖注入，那么久无法在构造函数中实现。为此，可以使用@PostConstruct注解一个方法来完成初始化，@PostConstruct注解的方法将会在依赖注入完成后被自动调用。
即：
Constructor >> @Autowired >> @PostConstruct

顺带复习下类的加载顺序：

1. 父类静态对象和静态代码块
2. 子类静态对象和静态代码块
3. 父类非静态对象和非静态代码块
4. 父类构造函数
5. 子类非静态对象和非静态代码块
6. 子类构造函数
7. 普通代码块

上述加载顺序中，类中静态代码块按照声明顺序执行，并且1和2在类加载到方法区的时候执行，也就是不需要在调用new实例的时候就执行了。

PostConstruct注释用于在完成依赖项注入以执行任何初始化之后需要执行的方法。必须在类投入使用之前调用此方法。
所有支持依赖注入的类都必须支持此注释。即使类没有请求注入任何资源，也必须调用使用PostConstruct注释的方法。
只有一个方法可以使用此批注进行批注。
应用PostConstruct注释的方法必须满足以下所有条件：除了拦截器之外，方法绝不能有任何参数，在这种情况下它采用Interceptor规范定义的InvocationContext对象。
在拦截器类上定义的方法必须具有以下签名之一：
void <METHOD>（InvocationContext）Object <METHOD>（InvocationContext）抛出异常注意：
PostConstruct拦截器方法不能抛出应用程序异常，但可以声明它抛出检查异常，包括java.lang.Exception，
如果相同的拦截器方法除了生命周期事件之外插入业务或超时方法。
如果PostConstruct拦截器方法返回一个值，容器将忽略它。
在非拦截器类上定义的方法必须具有以下签名：void <METHOD>（）应用PostConstruct的方法可以是public，protected，package private或private。
除应用程序客户端外，该方法绝不能是静态的。
该方法可能是最终的。如果该方法抛出一个未经检查的异常，那么该类绝不能投入使用，除非EJB可以处理异常甚至从它们恢复的EJB

@Service
public class BeanA {

    @Autowired
    private BeanB beanB;

    public BeanA() {
        System.out.println("这是Bean A 的构造方法");
    }


    @PostConstruct
    private void init() {
        System.out.println("这是BeanA的 init 方法");
        beanB.testB();
    }
}

@Service
public class BeanB {

    @PostConstruct
    private void init() {
        System.out.println("这是BeanB 的init 方法");
    }

    public BeanB() {
        System.out.println("这是Bean B的 构造方法");
    }

    void testB() {
        System.out.println("这是Bean B 的 testB 方法");
    }
}

启动后输出：

这是Bean A 的构造方法
这是Bean B的 构造方法
这是BeanB 的init 方法
这是BeanA的 init 方法
这是Bean B 的 testB 方法

论证了加载顺序：
Constructor > @Autowired > @PostConstruct

Servlet加载顺序理清之后，再论证类的加载顺序：

public class Test {

    public static Test t1 = new Test();// 标记1

    // 普通代码块
    {
        System.out.println("block A");// 标记2
    }

    // 静态代码块
    static {
        System.out.println("block B");// 标记3
    }

    public static void main(String[] args) {
        Test t2 = new Test();// 标记4
    }

}

out：

block A
block B
block A

解析：

首先进入Test类，没有父类，那就执行自身的静态对象和代码块，并且按照声明顺序执行。
所以首先执行标记1的静态对象，并且进行了实例化，所以需要调用相应的构造代码块，执行了标记2的语句，所以输出了block A；
执行完毕后顺序执行静态代码块，也就是标记3的语句，所以输出了blockB；
继续执行静态的main方法，重新实例化Test对象，再次调用构造代码块，再次输出了标记2的语句，所以再次输出了block A；