Spring Bean基本管理--bean注入方式汇总

时间:2021-08-24 16:57:35
依赖注入方式:Spring支持两种依赖注入方式,分别是属性注入和构造函数注入。还有工厂方法注入方式。
依赖注入还分为:注入依赖对象可以采用手工装配自动装配,在实际应用开发中建议使用手工装配,因为自动装配会产生许多未知情况,开发人员无法预见最终的装配结果。
手工装配依赖对象又分为3种方式:
1、编程方式(写的过程中向BeanFactory去注册)
2、是在XML文件中,通过在bean节点下配置;如上面讲到的使用属性的setter方法注入依赖对象和使用构造器方法注入依赖对象都是这种方式。
3、就是在java代码中使用注解的方式进行装配,在代码中加入@Resource或者@Autowired等,怎样使用注解的方式来为某个bena注入依赖对象呢?
自动装配依赖对象分为2种方式:
1、配置文件的bean中增加autowire
2、也可以选择在beans中加入default-autowire属性,为所有bean设置默认自动装配

Spring中提供了自动装配依赖对象的机制,但是在实际应用中并不推荐使用自动装配,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。

自动装配是在配置文件中实现的,如下:

<bean id="***" class="***" autowire="byType">

只需要配置一个autowire属性即可完成自动装配,不用再配置文件中写<property>,但是在类中还是要生成依赖对象的setter方法。

Autowire的属性值有如下几个:

· byType 按类型装配  可以根据属性类型,在容器中寻找该类型匹配的bean,如有多个,则会抛出异常,如果没有找到,则属性值为null;

· byName 按名称装配  可以根据属性的名称在容器中查询与该属性名称相同的bean,如果没有找到,则属性值为null;

· constructor 与byType方式相似,不同之处在与它应用于构造器参数,如果在容器中没有找到与构造器参数类型一致的bean,那么将抛出异常;

· autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器,那么将使用byType的方式。

---------------分割线-----------------------------------------------------------------------------------------------------
示例:
一、使用属性setter方法注入
下面是Bean和beans-config.xml文件。
public class HelloBean {  

    private String helloWord; 

    //...省略getter、setter方法     

}

xml文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="helloBean"
class="onlyfun.caterpillar.HelloBean">
<property name="helloWord">
<value>Hello!Justin!</value>
</property>
</bean>
</beans>

java:

public class SpringDemo {
public static void main(String[] args) {
Resource rs = new FileSystemResource("beans-config.xml");
BeanFactory factory = new XmlBeanFactory(rs); HelloBean hello = (HelloBean) factory.getBean("helloBean");
System.out.println(hello.getHelloWord());
}
}
二、使用constructor方式完成注入
其中xml配置有如下方式:
在配置文件中配置该类的bean,并配置构造器,在配置构造器中用到了<constructor-arg>节点,该节点有四个属性:

· index是索引,指定注入的属性,从0开始,如:0代表personDao,1代表str属性;

· type是指该属性所对应的类型,如Persondao对应的是com.aptech.dao.PersonDAO;

· ref 是指引用的依赖对象;

· value 当注入的不是依赖对象,而是基本数据类型时,就用value;

 java代码:
public class HelloBean {
private String name;
private String helloWord; // 建议有要无参数建构方法
public HelloBean() {
} public HelloBean(String name, String helloWord) {
this.name = name;
this.helloWord = helloWord;
} //...省略getter、setter方法
}

xml文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="helloBean"
class="onlyfun.caterpillar.HelloBean">
<constructor-arg index="0">
<value>Justin</value>
</constructor-arg>
<constructor-arg index="1">
<value>Hello</value>
</constructor-arg>
</bean>
</beans>

java代码:

public class SpringDemo {
public static void main(String[] args) {
ApplicationContext context =
new FileSystemXmlApplicationContext("beans-config.xml"); HelloBean hello = (HelloBean) context.getBean("helloBean");
System.out.print("Name: ");
System.out.println(hello.getName());
System.out.print("Word: ");
System.out.println(hello.getHelloWord());
}
}
三、属性参考
public class HelloBean {  
    private String helloWord;  
    private Date date;  
     
    //...省略getter、setter方法     
}
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
        <property name="date">  
            <ref bean="dateBean"/>  
        </property>  
    </bean>  
</beans>
public class SpringDemo {  
    public static void main(String[] args) {  
        ApplicationContext context =  
            new FileSystemXmlApplicationContext("beans-config.xml"); 
          
        HelloBean hello = (HelloBean) context.getBean("helloBean"); 
        System.out.print(hello.getHelloWord()); 
        System.out.print(" It's "); 
        System.out.print(hello.getDate()); 
        System.out.println("."); 
    }  
}
四、“byType”自动绑定
将“三”中的配置文件改为下面,即可完成bean属性的按类型自动绑定。
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="byType">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
    </bean>  
</beans>
五、“byName”自动绑定
将“三”中的配置文件改为下面,即可完成bean属性的按名称自动绑定。
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="byName">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
    </bean>  
</beans>
六、“constructor”自动绑定
将“三”中的配置文件改为下面,即可完成bean属性的按构造方法自动绑定。在建立依赖关系时,Srping容器会试图比对容器中的Bean实例类型,及相关的构造方法上的参数类型,看看在类型上是否符合,如果有的话,则选用该构造方法来建立Bean实例。如果无法绑定,则抛出org.springframework.beans.factory.UnsatisfiedDependencyException异常。
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="constructor">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
    </bean>  
</beans>
七、“autodetect”自动绑定
将“三”中的配置文件改为下面,即可完成bean属性的自动绑定,这个自动绑定是Spring会尝试用入constructor来处理依赖关系的建立,如果不行,则再尝试用byType类建立依赖关系。
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="autodetect">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
    </bean>  
</beans>
八、依赖检查方式
在自动绑定中,由于没办法从定义文件中,清楚地看到是否每个属性都完成设定,为了确定某些依赖关系确实建立,您可以假如依赖检查,在<bean>标签使用时设定"dependency-check",可以有四种依赖检查方式:simple、objects、all、none。
simple:只检查简单的类型(像原生数据类型或字符串对象)属性是否完成依赖关系,。
objects:检查对象类型的属性是否完成依赖关系。
all:则检查全部的属性是否完成依赖关系。
none:设定是默认值,表示不检查依赖性。
<beans>  
    <bean id="dateBean" class="java.util.Date"/>  
    <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="autodetect" dependeny-check="all">  
        <property name="helloWord">  
            <value>Hello!</value>  
        </property>  
    </bean>  
</beans>
九、集合对象注入
对于像数组、List、Set、Map等集合对象,在注入前必须填充一些对象至集合中,然后再将集合对象注入至所需的Bean时,也可以交由Spring的IoC容器来自动维护或生成集合对象,并完成依赖注入。
public class SomeBean { 
    private String[] someStrArray; 
    private Some[] someObjArray; 
    private List someList; 
    private Map someMap;

public String[] getSomeStrArray() { 
        return someStrArray; 
    } 
    public void setSomeStrArray(String[] someStrArray) { 
        this.someStrArray = someStrArray; 
    } 
    public Some[] getSomeObjArray() { 
        return someObjArray; 
    } 
    public void setSomeObjArray(Some[] someObjArray) { 
        this.someObjArray = someObjArray; 
    } 
    public List getSomeList() { 
        return someList; 
    } 
    public void setSomeList(List someList) { 
        this.someList = someList; 
    } 
    public Map getSomeMap() { 
        return someMap; 
    } 
    public void setSomeMap(Map someMap) { 
        this.someMap = someMap; 
    } 
}

public class Some { 
    private String name;

public String getName() { 
        return name; 
    } 
    public void setName(String name) { 
        this.name = name; 
    } 
    public String toString() { 
        return name; 
    } 
}

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"  
  "http://www.springframework.org/dtd/spring-beans.dtd">

<beans> 
    <bean id="some1" class="onlyfun.caterpillar.Some"> 
        <property name="name"> 
            <value>Justin</value> 
        </property> 
    </bean> 
     
    <bean id="some2" class="onlyfun.caterpillar.Some"> 
        <property name="name"> 
            <value>momor</value> 
        </property> 
    </bean> 
     
    <bean id="someBean" class="onlyfun.caterpillar.SomeBean"> 
        <property name="someStrArray"> 
            <list> 
                <value>Hello</value> 
                <value>Welcome</value> 
            </list> 
        </property> 
         
        <property name="someObjArray"> 
            <list> 
                 <ref bean="some1"/> 
                 <ref bean="some2"/> 
            </list> 
        </property> 
         
        <property name="someList"> 
            <list> 
                 <value>ListTest</value> 
                 <ref bean="some1"/> 
                 <ref bean="some2"/> 
            </list> 
        </property> 
         
        <property name="someMap"> 
            <map> 
                 <entry key="MapTest"> 
                     <value>Hello!Justin!</value> 
                 </entry> 
                 <entry key="someKey1"> 
                     <ref bean="some1"/> 
                 </entry> 
            </map> 
        </property> 
    </bean>  
</beans>

public class SpringDemo {  
    public static void main(String[] args) {  
        ApplicationContext context =  
            new FileSystemXmlApplicationContext( 
                    "beans-config.xml"); 
          
        SomeBean someBean =  
            (SomeBean) context.getBean("someBean"); 
         
        // 取得数组型态依赖注入对象 
        String[] strs =  
            (String[]) someBean.getSomeStrArray(); 
        Some[] somes =  
            (Some[]) someBean.getSomeObjArray(); 
        for(int i = 0; i < strs.length; i++) { 
            System.out.println(strs[i] + ","  
                    + somes[i].getName()); 
        }

// 取得List型态依赖注入对象 
        System.out.println(); 
        List someList = (List) someBean.getSomeList();  
        for(int i = 0; i < someList.size(); i++) { 
            System.out.println(someList.get(i)); 
        } 
         
        // 取得Map型态依赖注入对象 
        System.out.println(); 
        Map someMap = (Map) someBean.getSomeMap(); 
        System.out.println(someMap.get("MapTest")); 
        System.out.println(someMap.get("someKey1")); 
    }  
}

十、静态工厂的方法注入

静态工厂顾名思义,就是通过调用静态工厂的方法来获取自己需要的对象,为了让spring管理所有对象,我们不能直接通过"工程类.静态方法()"来获取对象,而是依然通过spring注入的形式获取:
同样看关键类,这里我需要注入一个FactoryDao对象,这里看起来跟第一种注入一模一样,但是看随后的xml会发现有很大差别:
Spring的IOC配置文件,注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类,而是指向静态工厂DaoFactory,并且配置 factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法:

十一、实例工厂的方法注入

实例工厂的意思是获取对象实例的方法不是静态的,所以你需要首先new工厂类,再调用普通的实例方法:
那么下面这个类没什么说的,跟前面也很相似,但是我们需要通过实例工厂类创建FactoryDao对象:
最后看spring配置文件: