Spring装配Bean的三种主要方案

作者: 郭之源 | 来源:发表于2016-08-15 21:00 被阅读1769次

这里说的Bean可不是豆子哦，是组件的意思，也就是哪些具有不同功能的类。将不同功能拆分成不同的组建，不仅能降低程序的耦合度，还能大大提升代码复用率。那么下面我们就来看看Spring装配Bean的三种主要方案吧！

1.隐式的Bean发现机制和自动装配

隐式的Bean发现机制，以其编写简单、实现方便的优点，成为企业级项目开发过程中使用最多的Bean装配机制。它主要是通过两步来实现Bean的装配和使用。

组建扫描（component scanning）:Spring 会自动发现应用上下文中所创建的bean。
自动装配（autowiring）:Spring 自动将满足类型或名称的Bean注入到使用到的类。
上代码,下面声明了一个组建dog:

package com.cache.service;
import org.springframework.stereotype.Repository;
/**
 * <dl>
 * <dd>Description:功能描述</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年8月11日 下午6:42:54</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Component("dog")
public class Dog {
    public void call(){
        System.out.println("汪汪汪...");
}

再声明一个组建My，使用了组建Dog:

package com.cache.service;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * <dl>
 * <dd>Description:功能描述</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年8月11日 下午6:42:22</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Component("my")
public class My {
    @Autowired(required=true)
    private Dog dog;
    
    public void shout(){
        dog.call();
    }
}

不过组建扫描默认是不启动的，所以我们要配置一下Spring，让它去寻找含有注解@Respository的类，然后为他们创建Bean。

package com.cache.service;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * <dl>
 * <dd>Description:功能描述</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年8月11日 下午6:49:55</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 * @ComponentScan(basePackages="com.cache")
 * @ComponentScan(basePackages={"com.package1","com.package2"})
 * @ComponentScan(basePackageClasses={Dog.class,My.class})
 * 以上是三种指定扫描包的方式
 */
@Configuration
//@ComponentScan(basePackages="com.cache")
//@ComponentScan(basePackages={"com.package1","com.package2"})
@ComponentScan(basePackageClasses={Dog.class,My.class})
public class MyConfig {

}

如果你习惯于使用XML进行组件扫描，那么可以使用Spring context命名空间的 <context:component-scan>元素。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:task="http://www.springframework.org/schema/task"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd">
    <!-- 自动扫描 --> <!-- 自动扫描指定的包中的类上的注解 -->
    <context:component-scan base-package="com.cache"/>
</beans>

做完这些之后就能使用注入到Spring容器中的Bean了。

2.在Java代码中进行显式装配

通过隐式扫描和自动装配实现Spring的自动配置的方式固然是方便快捷的，但是有些时候自动装配是行不通的，比如，需要使用到第三方库中的组件，这时候是没有办法在第三方类中添加@Component和@Autowired注解的，所以这个时候要使用到JavaConfig或Xml的方式进行组件配置了，下面我们先说一下使用JavaConfig的方式配置组件。

package com.cache.service;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * <dl>
 * <dd>Description:功能描述</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年8月11日 下午6:49:55</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */

@Configuration
// @ComponentScan(basePackages="com.cache")
// @ComponentScan(basePackages={"com.package1","com.package2"})
// @ComponentScan(basePackageClasses={Dog.class,My.class})
public class MyConfig {

    @Bean(name = "dog")
    public Dog dog() {
        return new Dog();
    }

    /**
     * 通过构造器注入方式注入
     * @return
     */
    //@Bean(name = "my")
    //public My my() {
    //  return new My(dog());
    //}

    /**
     * 通过get注入方式注入
     * @param dog
     * @return
     */
    @Bean
    public My my(Dog dog) {
        My my = new My(dog);
        my.setDog(dog);
        return my;
    }

}

3. 在XML中进行显示装配

Spring使用XMl装配Bean，已经有很久的历史了，曾经xml是主要装配bean的方式，但现在使用JavaConfig方式装配Bean很受提倡。现在很多企业还是比较习惯使用XML装配组件，下面我们就简单介绍一下使用XML装配Bean的实现吧。

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" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"
    default-lazy-init="true">


</beans>

在<beans></beans>标签中可以声明其他的bean和配置。
声明一个简单的bean：
<bean id="dog" class="com.cache.service.Dog" />

借助构造器注入初始化bean

Spring中可以使用<constructor-arg>元素和c命名空间对bean进行构造器注入参数:

<bean id="my" class="com.cache.service.My">
  <constructor-arg ref="dog"/>
  <constructor-arg value="Hello World"/>
</bean>

<bean id="my" class="com.cache.service.My"
    c:dog-ref="dog" 
    c:_title="Hello World"/>

也可以使用变量在构造器参数列表中的位置进行注入：

<bean id="my" class="com.cache.service.My"
    c:_0="haha" 
    c:_1="Hello World"/>

装配集合

<bean id="my" class="com.cache.service.My">
  <constructor-arg ref="dog"/>
  <constructor-arg value="Hello World"/>
  <constructor-arg>
    <list>
      <value>one</value>
      <value>two</value>
      <value>three</value>
      <value>four</value>
    </list>
  </constructor-arg>
  <constructor-arg>
    <set>
      <value>one</value>
      <value>two</value>
      <value>three</value>
      <value>four</value>
    </set>
  </constructor-arg>
  <constructor-arg>
     <map>
        <entry key="shiro.session.uncache" value-ref="sessionUncacheService"/>
        <entry key="wxCfgReloadChannel"> 
            <bean class="com.rocoinfo.rocomall.rest.admin.wx.WxReloadConfigHandler"/>
        </entry>
     </map>
   </constructor-arg>
</bean>

使用setter注入参数

setter注入是特别常用的注入属性的方式，它的基本语法如下：

<bean id="my" class="com.cache.service.My">
    <property name="dog" ref="dog" />
</bean>

同样的setter注入也有替代的命名空间，那就是p元素：

<bean id="my" class="com.cache.service.My" 
    p:dog-ref="dog" />

sertter方式注入字面量、list、set、map：

<bean id="my" class="com.cache.service.My">
    <property name="dog" ref="dog" />
    <property name="title" value="Hello World"/>
    <property name="statusList">
        <list>
          <value>one</value>
          <value>two</value>
          <value>three</value>
          <value>four</value>
        </list>
     </property>
     <property name="prodList">
        <set>
          <value>one</value>
          <value>two</value>
          <value>three</value>
          <value>four</value>
        </set>
     </property>
     <property name="wordbook">
        <map>
          <entry key="one" value="西游记"/>
          <entry key="one" value="红楼梦"/>
          <entry key="one" value="水浒传"/>
          <entry key="one" value="三国演义"/>
        </map>
     </property>
</bean>

当然也可以借助<util></util>元素将list、set、map等在bean外声明：

<util:list id="nameList">
    <value>one</value>
    <value>two</value>
    <value>three</value>
    <value>four</value>
</util:list>

下面四<util>中的子元素：

元素	描述
<util:content>	引用某个类型的public static 域，并将其暴露为bean
<util:list>	创建一个java.util.List类型的bean，其中包含值或引用
<util:set>	创建一个java.util.Set类型的bean，其中包含值或引用
<util:map>	创建一个java.util.Map类型的bean，其中包含值或引用
<util:propertys>	创建一个java.util.Properties类型的bean
<util:property-path>	引用一个bean的属性或内嵌属性，并将其暴露为一个bean

4. 混合配置

Javaconfig中导入其他JavaConfig或XML

使用@Import注解导入其他JavaConfig中的配置
使用@ImportResource导入XML中的配置

package com.cache.service;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

/**
 * <dl>
 * <dd>Description:功能描述</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年8月11日 下午9:04:20</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Configuration
@Import(MyConfig.class)//引用其他JavaConfig中的Bean
//@ImportResource("classpath:my-config.xml")//引用XML中配置的Bean
public class MyConfig2 {

    @Bean(name="my")
    public My my(Dog dog){
        
        My my = new My();
        my.setDog(dog);
        return my;
        //return new My(dog);
    }
}

XML中引入其他XML配置和将JavaConfig类引入XML

使用<import resource="applicationContext-shiro.xml"/>引入其他XML配置

<import resource="applicationContext-shiro.xml"/>

<bean class="com.cache.Myconfig"/>

通常企业级开发过程中会将两个或更多的装配类或XML文件组合起来，然后使用组建扫描（<context:component-scan>或@ComponentScan）将bean装配到Spring上下文中。到此我们就学完了Spring最核心、也是工作中使用最多的负责管理bean生命周期的Spring容器。

Spring装配Bean的三种主要方案

1.隐式的Bean发现机制和自动装配

2.在Java代码中进行显式装配

3. 在XML中进行显示装配

XML配置规范

借助构造器注入初始化bean

装配集合

使用setter注入参数

4. 混合配置

Javaconfig中导入其他JavaConfig或XML

XML中引入其他XML配置和将JavaConfig类引入XML

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读