Spring系列之bean的使用简介说明

实现bean的三个方式:
  1.使用构造器实例化Bean
  2.使用静态工厂方法实例化Bean
  3.使用实例工厂方法实例化Bean

Bean的定义

<bean id="userDao" class="com.java265.UserDao"/>
 其效果类似于
   UserDao userDao = new UserDao()。
 
bean定义语法:  
<bean
    id="beanId"（1）
    name="beanName"（2）
    class="beanClass"（3）
    parent="parentBean"（4）
    abstract="true | false"（5）
    singleton="true | false"（6）
    lazy-init="true | false | default"（7）
    autowire="no | byName | byType | constructor | autodetect | default"（8）
    dependency-check = "none | objects | simple | all | default"（9）
    depends-on="dependsOnBean"（10）
    init-method="method"（11）
    destroy-method="method"（12）
    factory-method="method"（13）
    factory-bean="bean">（14）
</bean>

（1）id: Bean 的唯一标识名。它必须是合法的 XML ID,
     在整个 XML 文档中唯一
（2）name: 用来为 id 创建一个或多个别名
     它可以是任意的字母符合。多个别名之间用逗号或空格分开
（3）class: 用来定义类的全限定名(包名＋类名)
     只有子类 Bean 不用定义该属性
（4）parent: 子类 Bean 定义它所引用它的父类 Bean
     这时前面的 class 属性失效
	  子类 Bean 会继承父类 Bean 的所有属性
	   子类 Bean 也可以覆盖父类 Bean 的属性
	    注意:子类 Bean 和父类 Bean 是同一个 Java 类
（5）abstract(默认为”false”):
     用来定义 Bean 是否为抽象 Bean
     它表示这个 Bean 将不会被实例化
     一般用于父类 Bean
      因为父类 Bean 主要是供子类 Bean 继承使用。

（6）singleton(默认为“true”):
     定义Bean是否是Singleton(单例)
	  如果设为“true”,则在BeanFactory作用范围内
        只维护此 Bean 的一个实例
     如果设为“flase”
       Bean将是Prototype(原型)状态
       BeanFactory 将为每次 Bean 请求创建一个新的 Bean 实例。

（7）lazy-init(默认为“default”):
     用来定义这个 Bean 是否实现懒初始化
	  如果为“true”
     它将在BeanFactory启动时初始化所有Singleton Bean
      如果为“false”,它只在 Bean 请求时才开始创建 Singleton Bean

（8）autowire(自动装配，默认为"default"):
     它定义了 Bean 的自动装载方式 
      "no":不使用自动装配功能 
      "byName":通过 Bean 的属性名实现自动装配
      "byType":通过 Bean 的类型实现自动装配
      "constructor":类似于 byType，但它是用于构造函数的参数的自动组装
      "autodetect":通过 Bean 类的反省机制（introspection）决定是使用“constructor”还是使用“byType”

（9）dependency-check（依赖检查，默认为“default”）:
     它用来确保 Bean 组件通过 JavaBean 描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用
       none:不进行依赖检查
       objects:只做对象间依赖的检查
       simple:只做原始类型和 String 类型依赖的检查
       all:对所有类型的依赖进行检查。它包括了前面的 objects 和 simple

（10）depends-on(依赖对象):
      Bean 在初始化时依赖的对象，这个对象会在这个 Bean 初始化之前创建

（11）init-method:
      用来定义 Bean 的初始化方法，它会在 Bean 组装之后调用。它必须是一个无参数的方法

（12）destroy-method:
      用来定义 Bean 的销毁方法
	    它在 BeanFactory 关闭时调用
		同样，它也必须是一个无参数的方法。它只能应用于singleton Bean

（13）factory-method:
     定义创建该 Bean 对象的工厂方法
	  它用于下面的"factory-bean"，表示这个 Bean 是通过工厂方法创建。"class"属性失效

（14）factory-bean:
     定义创建该 Bean 对象的工厂类
	  如果使用了"factory-bean"则"class"属性失效。

实例化Bean的三种方式

使用构造器实例化Bean

Spring IOC容器即能使用默认空构造器也能使用有参数构造器两种方式创建Bean 
使用空构造器进行定义
 class属性指定的类必须有空构造器
 使用有参数构造器进行定义
  可以使用< constructor-arg >标签指定构造器参数值
   其中index表示位置
       value表示常量值
  也可以指定引用
  指定引用使用ref来引用另一个Bean定义 

（1）定义一个接口

package com.spring.service;

public interface IUserService {
    public void show();
}
 （2）实现类，该类有一个空构造器和一个有参构造器:


package com.spring.service.impl;

import com.spring.service.IUserService;

public class UserServiceImpl implements IUserService{
    
    private String message;
    
    public UserServiceImpl(){
        this.message="java265";
    }
    
    public UserServiceImpl(String message){
        this.message=message;
    }
    
    public void show(){
        System.out.println("hello,"+message);
    }
}

（3）在配置文件（applicationContext1.xml）中配置Bean定义，如下所示:


<!-- 使用默认构造函数 -->
<bean id="bean1" class="com.spring.service.impl.UserServiceImpl">  
</bean>
    
<!-- 使用有参数构造函数 -->
<bean id="bean2" class="com.spring.service.impl.UserServiceImpl" >
    <!-- 指定构造器参数 -->
    <constructor-arg index="0" value="java265" />
</bean>

（4）测试

/**
 * 使用构造器实例化Bean
 */
@Test
public void testCreateBeanByConstructor(){
    //读取配置文件
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext1.xml");
    //获取bean的实例
    IUserService bean1=(IUserService) ctx.getBean("bean1");
    //调用方法
    bean1.show();
    
    IUserService bean2=(IUserService) ctx.getBean("bean2");
    bean2.show();
}

使用静态工厂方法实例化Bean

（1）定义静态工厂类:


package com.spring.factory;

import com.spring.service.IUserService;
import com.spring.service.impl.UserServiceImpl;

public class UserStaticFactory {
    //工厂方法
    public static IUserService newInstance(String message){
        //返回需要的Bean实例
        return new UserServiceImpl(message);
    }
}

（2）在配置文件（applicationContext1.xml）中配置Bean定义，如下所示:

  <!-- 使用静态工厂方法 -->
  <bean id="bean3" class="com.spring.factory.UserStaticFactory" factory-method="newInstance" >
      <constructor-arg index="0" value="java265" />
  </bean>

（3）测试 
/**
 * 使用静态工厂实例化Bean
 */
@Test
public void testCreateBeanByStaticFactory(){
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext1.xml");
    IUserService bean3=(IUserService) ctx.getBean("bean3");
    bean3.show();
}

使用实例工厂方法实例化Bean

 
（1）定义实例工厂类
package com.spring.factory;

import com.spring.service.IUserService;
import com.spring.service.impl.UserServiceImpl;

public class UserInstanceFactory {
    
    public IUserService newInstance(String message){
        return new UserServiceImpl(message);
    }
}

（2）在配置文件（applicationContext1.xml）中配置Bean定义，如下所示:

  <!-- 1.定义实例工厂Bean -->
  <bean id="beanInstanceFactory" class="com.spring.factory.UserInstanceFactory" />
  <!-- 2.使用实例工厂Bean创建Bean -->
  <bean id="bean4" factory-bean="beanInstanceFactory" factory-method="newInstance" >
       <constructor-arg index="0" value="java265"></constructor-arg>
  </bean> 

（3）测试
/**
 * 使用实例工厂实例化Bean
 */
@Test
public void testCreateBeanByInstanceFactory(){
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext1.xml");
    IUserService bean4=(IUserService) ctx.getBean("bean4");
    bean4.show();
}

Bean的作用域

我们将对象或变量之间的可见范围称之为"Bean作用域"
 Bean作用域分为以下几种:
    singleton,prototype,request,
	session,globalSession