Spring 学习——Bean容器

Bean容器初始化

基础
- org.springframework.beans
- org.springframework.context
- BeanFactory提供配置结构和基本功能，加载并初始化Bean
- ApplicationContext保存了Bean对象，并且在Spring进行使用

ApplicationContext范围

加载本地文件

FileSystemXmlApplication context = new FileSystemXmlApplicationContext("F://test//context.xml");

加载ClassPath文件

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*/resources/context.xml");

web应用配置文件

Spring注入方式

定义：Spring注入是指启动Spring容器启动并加载Bean的过程中，完成对变量的赋值行为

注入方式：

设值注入:是将变量以Set属性的方式注入到Bean中，使用设置注入，在Bean中一定要有变量的Set方法，配置中的<property>标签name的值一定要和属性名称一致！！！

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" >

    <bean id="InjectionServiceImpl" class="com.jing.spring.bean.InjectionServiceImpl">
        <property name="injectionDao" ref="injectionDao"></property>
    </bean>
    <bean id="injectionDao" class="com.jing.spring.bean.InjectionDaoImpl"></bean><!--??????不懂  程序中是引用接口 为什么却要把实现类注入？-->
</beans>

private InjectionDao injectionDao;

    public void setInjectionDao(InjectionDao injectionDao) {
        this.injectionDao = injectionDao;
    }

    public void save(String arg) {
        System.out.print("InjectionServiceImpl中的arg==="+arg+"
");
        //逻辑处理
        arg=arg+":"+this.hashCode();
        injectionDao.save(arg);
    }

构造注入：是将变量作为Bean构造器的参数传入，在Bean中一个要有一个以变量作为参数的构造函数，配置中的<constructor-arg>标签name的值一定要和有参构造方法参数名称一致！！！

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" >

        <bean id="InjectionServiceImpl" class="com.jing.spring.bean.InjectionServiceImpl">
            <constructor-arg name="injectionDao" ref="injectionDao"></constructor-arg>
        </bean>
        
        <bean id="injectionDao" class="com.jing.spring.bean.InjectionDaoImpl"></bean>
 </beans>

private InjectionDao injectionDaoss;

    InjectionServiceImpl(InjectionDao injectionDao){
        this.injectionDaoss=injectionDao;
    }
    public void save(String arg) {
        System.out.print("InjectionServiceImpl中的arg==="+arg+"
");
        //逻辑处理
        arg=arg+":"+this.hashCode();
        injectionDaoss.save(arg);
    }

Bean的配置项

Id
Class
Scope
Contructor arguments
Properties
Autowiring mode
lazy_initialization mode
Initialization/destruction mothod

Bean的作用域

singleton:单例。一个Bean容器中只存在一个Bean对象。
prototype:每次请求创建实例都会产生一个新的实例，destroy不生效。
request:每次请求创建一个新的实例且在当前request内有效。
session:同上，每次http请求创建一个新的实例，且在当前session有效。
global session:基于portlet的web中有效（portlet定义了 global session)。如果是在web中，同session。使用在多个系统之间，一个session控制不了多个系统。

Bean的生命周期

定义：XML文件中<bean>的定义
初始化：获取一个实例的时候
使用：使用
销毁：销毁

初始化/销毁方法：这两个方法是为了在初始化/销毁Bean容器的时候执行一些额外的方法

针对Bean实例的销毁，只有在Bean是单例singleton模式的前提下，Bean才会随着Bean容器的销毁而销毁。在原型prototype的模式下，Bean实例在创建后，就会交由用户进行管理，所以此时Bean实例的销毁不是由Bean容器决定。举例：在原型模式中，根据电影票类初始化两个实例，也就是两张电影票，这个时候，不能因为一张电影票的作废，另一张电影票也随之作废。电影票的管理应该交由用户来管理。

方式一：XML中每一个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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" >
        
    <bean id="springLifeDate" class="com.jing.spring.lifedate.SpringLifeDate" init-method="start" destroy-method="end"></bean>
    
 </beans>

package com.jing.spring.lifedate;

public class SpringLifeDate1 {

    public void start(){
        System.out.println("SpringLifeDate开始执行。。。。");
    }
    public void excecute(){
        System.out.println("SpringLifeDate执行中。。。。");
    }
    public void end(){
        System.out.println("SpringLifeDate执行结束。。。。");
    }
}

PS：这种方法针对每个Bean设置的初始化/销毁时执行的方法。在Bean容器初始化时主动执行init-method设置的类中的方法，Bean容器销毁后执行destroy-method设置的方法。如果在XML中进行方法设置，Bean类中创造方法，会报错。

方式二：在Bean的类中实现接口，实现初始化方法/销毁方法

package com.jing.spring.lifedate;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class SpringLifeDate2 implements InitializingBean, DisposableBean {

    public void afterPropertiesSet() throws Exception {
        System.out.println("SpringLifeDate开始执行。。。。");
    }
    public void excecute(){
        System.out.println("SpringLifeDate执行中。。。。");
    }
    public void destroy() throws Exception {
        System.out.println("SpringLifeDate执行结束。。。。");
    }
}

PS:这种方法是Bean中实现接口实现Bean初始化/销毁时执行的方法。Bean初始化后执行的方法需要实现InitializingBean接口重写afterPropertiesSet方法，Bean销毁后执行的方法需要实现DisposableBean接口重写destroy方法。

方式三：在XML中声明全局初始化方法/销毁方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd"
    default-init-method="defaultInit" default-destroy-method="defaultDestroy" >
 </beans>

package com.jing.spring.lifedate;

public class SpringLifeDate3 {
    public void defaultInit() throws Exception {
        System.out.println("SpringLifeDate3开始执行。。。。");
    }
    public void excecute(){
        System.out.println("SpringLifeDate执行中。。。。");
    }
    public void defaultDestroy() throws Exception {
        System.out.println("SpringLifeDate3执行结束。。。。");
    }
}

PS:这种方式生命Bean的初始化/销毁方法，在类中没有相对应得方法，也不会报错。

执行顺序
- 在三种方式同时存在的情况下：只会执行方式一（每一个Bean实例声明）和方式二（实现类方式）中定义的初始化/销毁方法，执行顺序为方式二（实现类方式）>方式一（每一个Bean实例声明）
- 在方式三（全局配置）和其他任一方式同时存在，方式三（全局配置）都不会执行，只会执行另一种方式中定义的初始化/销毁方法。