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

戚薇 Spring 2022-07-18 22:10:46 4528 1
下文笔者讲述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
版权声明

本文仅代表作者观点,不代表本站立场。
本文系作者授权发表,未经许可,不得转载。

本文链接: http://www.Java265.com/JavaFramework/Spring/202207/4001.html

最近发表

热门文章

好文推荐

Java265.com

//www.java265.com

站长统计|USA-001

Powered By Java265.com信息维护小组

使用手机扫描二维码

关注我们看更多资讯

Honor accompaniments