Spring的初始化顺序

在spring的配置文件中配置bean，如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="one" class="cn.itcast_04_springannotation.springrunorder.One">
        <constructor-arg name="one" value="one"/>
    </bean>
    <bean id="two" class="cn.itcast_04_springannotation.springrunorder.Two">
        <constructor-arg name="two" value="two" />
    </bean>
</beans>

在One类和Two类中，分别实现一个参数的构造如下：

package cn.itcast_04_springannotation.springrunorder;
public class One{
    public One(String one) {
        System.out.println(one);
    }
}
package cn.itcast_04_springannotation.springrunorder;
public class Two {
    public Two(String two) {
        System.out.println(two);
    }
}

加载spring配置文件，初始化bean如下：

package cn.itcast_04_springannotation.springrunorder;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Start { 
    public static void main(String[] args) {
        new ClassPathXmlApplicationContext("spring.xml");
    }
}

这里写图片描述

结论：spring会按照bean的顺序依次初始化xml中配置的所有bean

通过ApplicationContextAware加载Spring上下文环境

在One中实现ApplicationContextAware接口会出现如何的变换呢？

package cn.itcast_04_springannotation.springrunorder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class One implements ApplicationContextAware { 
    public One(String one) {
        System.out.println(one);
    }
    @Override
    public void setApplicationContext(ApplicationContext arg0)
            throws BeansException {
            System.out.println("setApplicationContext");
    }
}

这里写图片描述

InitializingBean的作用

在One中实现InitializingBean接口呢?

package cn.itcast_04_springannotation.springrunorder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class One implements ApplicationContextAware ,InitializingBean { 
    public One(String one) {
        System.out.println(one);
    }
    @Override
    public void setApplicationContext(ApplicationContext arg0)
            throws BeansException {
            System.out.println("setApplicationContext");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");
    }
}

这里写图片描述

如果使用注解@Component

使用@Component注入类，那么它的顺序是如何呢？

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="one" class="cn.itcast_04_springannotation.springrunorder.One">
        <constructor-arg name="one" value="one"/>
    </bean>
    <context:component-scan base-package="cn.itcast_04_springannotation.springrunorder"/>
    <bean id="two" class="cn.itcast_04_springannotation.springrunorder.Two">
        <constructor-arg name="two" value="two" />
    </bean>
</beans>
package cn.itcast_04_springannotation.springrunorder;
import org.springframework.stereotype.Component;
@Component
public class Three {
    public Three() {
        System.out.println("three");
    }
    public Three(String three) {
        System.out.println(three);
    }
}

这里写图片描述

结论

1、 spring先检查注解注入的bean，并将它们实例化
2、然后spring初始化bean的顺序是按照xml中配置的顺序依次执行构造
3、如果某个类实现了ApplicationContextAware接口，会在类初始化完成后调用setApplicationContext（）方法进行操作
4、如果某个类实现了InitializingBean接口，会在类初始化完成后，并在setApplicationContext（）方法执行完毕后，调用afterPropertiesSet（）方法进行操作

注解使用回顾

1、在spring中，用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package="pagkage1[,pagkage2,…,pagkageN]"/>。
2、如果某个类的头上带有特定的注解@Component/@Repository/@Service/@Controller，就会将这个对象作为Bean注册进Spring容器
3、在使用spring管理的bean时，无需在对调用的对象进行new的过程，只需使用@Autowired将需要的bean注入本类即可

自定义注解

解释

1、自定义注解的作用：在反射中获取注解，以取得注解修饰的“类、方法、属性”的相关解释。
2、java内置注解
@Target 表示该注解用于什么地方，可能的 ElemenetType 参数包括：
ElemenetType.CONSTRUCTOR 构造器声明
ElemenetType.FIELD 域声明（包括 enum 实例）
ElemenetType.LOCAL_VARIABLE 局部变量声明
ElemenetType.METHOD 方法声明
ElemenetType.PACKAGE 包声明
ElemenetType.PARAMETER 参数声明
ElemenetType.TYPE 类，接口（包括注解类型）或enum声明
@Retention 表示在什么级别保存该注解信息。可选的 RetentionPolicy 参数包括：
RetentionPolicy.SOURCE 注解将被编译器丢弃
RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃
RetentionPolicy.RUNTIME JVM将在运行期也保留注释，因此可以通过反射机制读取注解的信息。

实现

1.定义自定义注解

package cn.itcast_04_springannotation.userdefinedannotation.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.stereotype.Component;
@Target({ ElementType.TYPE })//注解用在接口上
@Retention(RetentionPolicy.RUNTIME)//VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
@Component
public @interface RpcService {
    String value();
}

2、将直接类加到需要使用的类上，我们可以通过获取注解，来得到这个类

package cn.itcast_04_springannotation.userdefinedannotation.service.impl;
import cn.itcast_04_springannotation.userdefinedannotation.annotation.RpcService;
import cn.itcast_04_springannotation.userdefinedannotation.service.HelloService;
@RpcService("HelloServicebb")
public class HelloServiceImpl implements HelloService { 
    public String hello(String name) {
        return "Hello! " + name;
    }
    public void test(){
        System.out.println("test");
    }
}

3、类实现的接口

package cn.itcast_04_springannotation.userdefinedannotation.service;
public interface HelloService {
    String hello(String name);
}

4、通过ApplicationContext获取所有标记这个注解的类

package cn.itcast_04_springannotation.userdefinedannotation.test;
import java.lang.reflect.Method;
import java.util.Map;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import cn.itcast_04_springannotation.userdefinedannotation.annotation.RpcService;
import cn.itcast_04_springannotation.userdefinedannotation.service.HelloService;
@Component        //ApplicationContextAware会为Component组件调用setApplicationContext方法；
public class MyServer implements ApplicationContextAware {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring2.xml");
    }
    public void setApplicationContext(ApplicationContext ctx)
            throws BeansException {
        Map<String, Object> serviceBeanMap = ctx
                .getBeansWithAnnotation(RpcService.class);
        for (Object serviceBean : serviceBeanMap.values()) {
            try {
                //获取自定义注解上的value
                String value = serviceBean.getClass().getAnnotation(RpcService.class).value();
                System.out.println("注解上的value: " + value);
                //反射被注解类，并调用指定方法
                Method method = serviceBean.getClass().getMethod("hello",
                        new Class[] { String.class });
                Object invoke = method.invoke(serviceBean, "bbb");
                System.out.println(invoke);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

这里写图片描述

package cn.itcast_04_springannotation.userdefinedannotation.test;
import java.lang.reflect.Method;
import java.util.Map;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import cn.itcast_04_springannotation.userdefinedannotation.annotation.RpcService;
import cn.itcast_04_springannotation.userdefinedannotation.service.HelloService;
public class MyServer2 implements ApplicationContextAware {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring2.xml");
        Map<String, Object> beans = ctx.getBeansWithAnnotation(RpcService.class);
        for(Object obj: beans.values()){
            HelloService hello=(HelloService) obj;
            String hello2 = hello.hello("mmmm");
            System.out.println(hello2);
        }
    }
    public void setApplicationContext(ApplicationContext ctx)
            throws BeansException {
        Map<String, Object> serviceBeanMap = ctx
                .getBeansWithAnnotation(RpcService.class);
        for (Object serviceBean : serviceBeanMap.values()) {
            try {
                Method method = serviceBean.getClass().getMethod("hello",
                        new Class[] { String.class });
                Object invoke = method.invoke(serviceBean, "bbb");
                System.out.println(invoke);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

这里写图片描述

5、结合spring实现junit测试

package cn.itcast_04_springannotation.userdefinedannotation.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cn.itcast_04_springannotation.userdefinedannotation.service.HelloService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring2.xml")
@Component
public class MyServer3 {
    @Autowired
    HelloService helloService;
    @Test
    public void helloTest1() {
        System.out.println("开始junit测试……");
        String hello = helloService.hello("ooooooo");
        System.out.println(hello);
    }
}