Spring中实例化bean的四种方式详解

前言

在介绍bean的实例化的方式之前，我们首先需要介绍一下什么是bean，以及bean的配置方式。

如果把spring看作一个大型工厂，那么spring容器中的bean就是该工厂的产品。要想使用spring工厂生产和管理bean，就需要在配置文件中指明需要哪些bean，以及需要使用何种方式将这些bean装配到一起。

spring容器支持两种格式的配置文件，分别为properties文件格式和xml文件格式，而在实际的开发当中，最常使用的额是xml文件格式，因此在如下的讲解中，我们以xml文件格式的配置方式进行说明。xml配置文件的根元素是<beans>，其可以包含多个子元素<bean>，每个子元素定义一个bean，并描述了bean该如何被装配到spring容器中。<bean>元素中的属性如下：

• id：bean的唯一标识符，spring对bean的配置、管理都通过该属性来完成；
• name：spring同样可以通过name对bean进行配置和管理，name属性可以为bean定义多个名称，每个名称以逗号隔开；
• class：该属性指定了bean的具体实现类，必须是一个完成的类名，使用类的全限定名；
• scope：设定bean实例的作用域，其属性有singleton（单例）、prototype（原型）、request、session、和global session，默认值为singleton，该属性会在下一篇博客中详细讲解；
• constructor-arg：<bean>元素的子元素，可以使用此元素传入构造参数进行实例化（上一篇博客的最后补充就是使用此属性进行实例化的），该元素的index属性指定构造参数的序号（从0开始）；
• property：<bean>元素的子元素，通过调用bean实例中的setter方法完成属性赋值，从而完成依赖注入；
• ref：property、constructor-arg等元素的子元素，该元素中的bean属性用于指定对bean工厂中某个bean实例的引用；
• value：property、constructor-arg等元素的子元素，用来直接指定一个常量值；
• list：用于封装list或数组类型的依赖注入；
• set：用于封装set或数组类型的依赖注入；
• map：用于封装map或数组类型的依赖注入；
• entry：map元素的子元素，用于设定一个键值对，其key属性指定字符串类型的键值，ref或value子元素指定其值。

在配置文件中，通常一个普通的bean只需要定义id和class两个属性即可，定义bean的方式如下：

<?xml version="1.0" encoding="utf-8"?>
<!doctype beans public "-//spring//dtd bean//en"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!-- 将指定对象配置给spring，让spring创建其实例 -->
    <bean id="userdao" class="com.ioc.userdaoimpl"/>
    <bean name="userdao1, userdao2" class="com.ioc.userdaoimpl2"/>
</beans>

上述代码中，分别使用id和name属性定义了两个bean，并使用class元素指定其对应的实现类，如果未指定id和name，则spring会将class值当做id使用。

spring实例化bean的四种方式

本文主要介绍四种实例化bean的方式(注入方式) 或者叫依赖对象实例化的四种方式。上面的程序,创建bean 对象,用的是什么方法 ,用的是构造函数的方式 (spring 可以在构造函数私有化的情况下把类对象创建出来)

常用的创建方式有以下四种：

1) setter 方法

2) 构造函数

3) 静态工厂

4) 实例工厂

一、用 setter 方式

public interface iuserdao {
    void adduser();
    void deluser();
    void updateuser();
   }
   public class userdaoimpl implements iuserdao {
    public void adduser() {
     system.out.println("adduser方法被调用了");
    }  
    public void deluser() {
     system.out.println("deluser方法被调用了");
    }  
    public void updateuser() {
     system.out.println("updateuser方法被调用了");
    }
   }
   public class useraction {
     private iuserdao dao; //dao是一个依赖对象,要由springg进行管理,要生成 get set 方法
       public void execute(){
       dao.adduser();
       dao.updateuser();
       dao.deluser();
     }
    }

//配置文件
<bean name="useraction_name" class="cat.action.useraction" >
<property name="dao" ref="userdao_name" /> //引用的是下面的名称
</bean> 
<bean name="userdao_name" class="cat.dao.userdaoimpl" />

//测试
classpathxmlapplicationcontext ctx=new classpathxmlapplicationcontext("beans.xml");
useraction action=(useraction)ctx.getbean("useraction_name");
action.execute(); 

二、构造函数

public class useraction {
  //public useraction(){} 可以保保留一个无参的构造函数 
  //这是几个依赖对象,不用生成get set方法了
  private userinfo user;
  private string school;
  private iuserdao dao;  
  //希望spring 由构造函数注入依赖对象
  public useraction(iuserdao dao,userinfo user,string school){
    this.dao=dao;
    this.school=school;
    this.user=user;
    } 
  public void execute(){
    dao.adduser();
    dao.updateuser();
    dao.deluser(); 
    system.out.println(user);
    system.out.println(school);
}

//配置文件
<bean name="userinfo_name" class="cat.beans.userinfo" >
  <property name="id" value="1" />
  <property name="username" value="周周" />
  <property name="password" value="123" />
  <property name="note" value="这是备注" />
</bean>   
<bean name="useraction_name" class="cat.action.useraction" >
  <constructor-arg ref="userdao_name" />
  <constructor-arg ref="userinfo_name" />
  <constructor-arg value="哈尔滨师范大学" />
</bean> 
/*
也可以指定 索引和 type 属性 , 索引和type 都可以不指定
<bean name="useraction_name" class="cat.action.useraction" >
<constructor-arg index="0" ref="userdao_name" type="cat.dao.iuserdao" /> 如果是接口,就不能指定是实现类的类型
<constructor-arg index="1" ref="userinfo_name" type="cat.beans.userinfo" />
<constructor-arg index="2" value="哈尔滨师范大学" />
</bean>
*/   
<bean name="userdao_name" class="cat.dao.userdaoimpl" />

//测试
classpathxmlapplicationcontext ctx=new classpathxmlapplicationcontext("beans.xml");
useraction action=(useraction)ctx.getbean("useraction_name");
action.execute(); 

三、静态工厂方式

//工厂,用来生成dao的实现类
public class userdaofactory {
public static iuserdao createuserdaoinstance(){
  return new userdaooracleimpl();
  }
} 
public class useraction {
  private iuserdao dao;//使用工厂方式注值,也要生成set方法
  public void execute(){
    dao.adduser();
    dao.updateuser();
    dao.deluser();
}
public void setdao(iuserdao dao) {
    this.dao = dao;
    } 
}

//配置文件 
<bean name="useraction_name" class="cat.action.useraction" >
<property name="dao" ref="userdao_name" />
</bean>
<bean name="userdao_name" class="cat.dao.userdaofactory" factory-method="createuserdaoinstance" />

//测试
classpathxmlapplicationcontext ctx=new classpathxmlapplicationcontext("beans.xml");
useraction action=(useraction)ctx.getbean("useraction_name");
action.execute(); 

四、实例工厂

//工厂 =>
public class userdaofactory {
//这个方法不是静态的
public iuserdao createuserdaoinstance(){
  return new userdaooracleimpl();
  }
}

//配置文件 
<bean name="useraction_name" class="cat.action.useraction" >
<property name="dao" ref="userdao_name" />
</bean>
<bean name="userdaofactory_name" class="cat.dao.userdaofactory" />
<bean name="userdao_name" factory-bean="userdaofactory_name" factory-method="createuserdaoinstance" />

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。