spring-Ioc容器与bean

1. spring 的beanFactory容器

bean.xml  HelloWorld实体类与spring教程学习笔记1相同

    public static void main(String[] args) {
        //XmlBeanFactory() API 去生成工厂 bean 以及利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件。
        //XmlBeanFactory() API 负责创建并初始化所有的对象，即在配置文件中提到的 bean。
        @SuppressWarnings("deprecation")
        XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource("beans1.xml"));
        HelloWorld obj=(HelloWorld)factory.getBean("helloword");
        obj.getMessage();
    }

spring 的ApplicationContext容器

    public static void main(String[] args) {
        //该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供给构造器 XML 文件的完整路径
        ApplicationContext context=new FileSystemXmlApplicationContext("E:\\MyWorkspace\\HelloSpring\\src\\beans1.xml");
        HelloWorld obj=(HelloWorld)context.getBean("helloword");
        obj.getMessage();
    }

//不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可
ApplicationContext context=new ClassPathXmlApplicationContext("beans1.xml");

2.  spring bean的作用域

在xml文件中定义bean的时候，去定义bean的属性scope

scope=“Singleton”创建容器时就自动创建一个bean，每次获取bean时获取的是同一个bean对象

scope=“prototype”创建容器时并没有去实例化bean对象，而是在获取bean时实例化一个新对象。

3.  spring bean 生命周期

参数 init-method 指定一个方法在实例化bean的时候调用

参数 destroy-method 指定一个方法在销毁bean之后调用

beans.xml

 <bean id="helloword" class="com.tutorialspoint.HelloWorld" scope="singleton" init-method="inint" destroy-method="destroy">
 </bean>

HelloWord实体类

public class HelloWorld {
    private String message;
    public String getMessage() {
        System.out.println("your mesage is:"+message);
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    //在bean初始化后会调用
    public void inint(){
        System.out.println("start bean");
    }
    //在bean被销毁后会调用
    public void destroy(){
        System.out.println("end bean");
    }
}

bean的加载，实例化，销毁

    public static void main(String[] args) {
        @SuppressWarnings("deprecation")
        XmlBeanFactory context=new XmlBeanFactory(new ClassPathResource("beans1.xml"));
        HelloWorld obj=(HelloWorld)context.getBean("helloword");
        obj.setMessage("11111");
        obj.getMessage();
        context.destroySingleton("helloword");
    }

4. spring bean后置处理器

这里插入两个后置处理器

beans.xml

 <bean id="helloword" class="com.tutorialspoint.HelloWorld" scope="singleton" init-method="inint" destroy-method="destroy">
  </bean>
  <bean class="com.tutorialspoint.InitHelloworld"></bean>
  <bean class="com.tutorialspoint.InitHelloWorld1"></bean>

HelloWorld.java实体类与上面相同

InitHelloWorld.java  和InitHelloWorld1.java两个后置处理类

public class InitHelloworld implements BeanPostProcessor,Ordered{
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("0****BeforeInitialization: beanName is:"+beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("0****AfterInitialization: beanName is:"+beanName);
        return bean;
    }
    @Override
    public int getOrder() {
        return 0;
    }
}

加载，初始化，应用bean，销毁bean

        AbstractApplicationContext context=new ClassPathXmlApplicationContext("beans1.xml");
        HelloWorld obj=(HelloWorld)context.getBean("helloword");
        obj.setMessage("1111");
        obj.getMessage();
        context.registerShutdownHook();//销毁bean

对于InitHelloWorld1.java，只需要修改0为1即可，后置处理器的执行顺序会根据order的返回值来确定

最终结果：

0****BeforeInitialization: beanName is:helloword   后置处理器0 初始化前执行函数

1****BeforeInitialization: beanName is:helloword   后置处理器1 初始化前执行函数

start bean                                                                 bean在实例化后调用

0****AfterInitialization: beanName is:helloword      后置处理器0 初始化后执行函数

1****AfterInitialization: beanName is:helloword      后置处理器1 初始化后执行函数

your mesage is:1111                                                 bean的调用

end bean                                                                   bean在销毁后调用函数

5. spring bean 定义继承

beans.xml

    <bean id="hello" class="com.test.Hello">
        <property name="message1" value="hello111"></property>
        <property name="message2" value="hello222"></property>
    </bean>

    <bean id="hello2" class="com.test.Hello2" parent="hello">
        <property name="message1" value="hell02_111"></property>
        <property name="message3" value="hello3_333"></property>
    </bean>

Hello.java

public class Hello {
    private String message1;
    private String message2;

Hello2.java

public class Hello2 {
    private String message1;
    private String message2;
    private String message3;

运行下面代码后：

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Hello obj=(Hello)context.getBean("hello");
        obj.getMessage1();
        obj.getMessage2();

        Hello2 obj2=(Hello2)context.getBean("hello2");
        obj2.getMessage1();
        obj2.getMessage2();
        obj2.getMessage3();
    }

我们发现结果是，在obj2中我们并没有传message2的值，但它显示的是Hello中传的值。

spring bean定义的继承与java 类中定义的继承无关，不然的话，在java类的继承中，对于

子类来说，父类的private是不可见的，更不用说去继承它的值了。

参考文章：w3cschool学习教程