2.3 Bean装配

1、Spring容器成功启动的条件

  • Spring框架的类包都已放在应用程序的类路径；
  • 应用程序为Spring提供完备的Bean信息；
  • Bean的类都已放到应用程序的类路径下。

2、Bean配置信息是Bean的元素据信息，由4个方面组成：

  • Bean的实现类；
  • Bean的属性信息（如数据源的连接数、用户名、密码）；
  • bean的依赖关系，Spring根据依赖关系配置完成Bean间的装配；
  • Bean的行为配置（如生命周期范围及生命周期各过程的回调函数）。

2.3.1 Bean基本配置

Bean命名      

      id为Bean的名称，通过容器的getBean("foo")获取对应的Bean，在容器中起到定位查找的作用，是外部程序和Spring IoC容器进行交互的桥梁，class指定了Bean对应的实现类。

        id（XML规定的特殊属性）在IoC容器中必须唯一，还需满足XML对id的命名规范：字母开始，后接字母、数字、连字符、下划线、句号、冒号等完整结束符。逗号、空格这些非完整结束符是非法的。

        name属性几乎可用任何字符，

<bean name="#car" class="com.Car"/>

        id和name都可指定多个名字，名字间用逗号、分号或空格分隔。用户可用getBean（"123"）或另外两种名字获取IoC容器中的CarBean。

<bean name="#car,123,$Car" class="com.Car"/>

        Spring配置文件不允许两个相同id的<bean>；但允许相同name的<bean>，getBean时会返回最后声明的那个Bean，后面的Bean覆盖了前面同名的Bean。So，尽量使用id而不是name命名的Bean。

        如果id、name都未指定，如①<bean  class="com.Car"/>，Spring自动将全限定类名作为Bean的名称，可通过②getBean（"com.Car"）获取CarBean，如果存在多个实现类相同的匿名<bean>即多个①处的Bean，第一个Bean通过②获得，第二个Bean通过getBean("com.Car#1")获得，以此类推。

2.3.2 依赖注入

1）属性注入

    setXxx（）方法，可选择性、灵活性高，最常用。

    要求Bean提供默认的构造函数，并未需要注入的属性提供对应的Setter方法。Spring先调用Bean的默认    构造函数实例化Bean对象，然后通过反射调用Setter方法注入属性值。

【默认构造函数】

        默认构造函数不带参。Java规定如果类中没有定义任何构造函数，JVM自动生成一个默认构造函数。反之，如果类中显示定义了构造函数，JVM将不会自动生成。So，类中显示定义了一个带参构造函数，则需同时提供一个默认构造函数，否则属性注入时将抛出异常。

        Spring只会检查Bean中是否有对应的Setter，是否有对应属性变量则不作要求。但一般约定俗成在Bean中提供同名的属性变量。

【Java属性变量】

        一般以小写字母起头，JavaBean允许大写字母开头，但必须满足“变量的前两个字母要么全部大写，要么全部小写”，brand、IDCode合法，iC、IDCode非法。

2）构造函数注入

        保证一些必要属性在Bean实例化时就得到设置，并确保Bean实例在实例化后就可以使用。使用构造函数的前提是Bean必须提供带参的构造函数。

Spring中构造函数注入的配置方式

注入时若匹配的构造函数不止一个，默认匹配最后一个构造函数。

Bean存在多个构造函数时，尽可能显示指定index、type。

①ByType：

<!--构造注入-类型匹配入参-->

<bean id="car1" class="com.smart.injection.Car">
    <constructor-arg type="java.lang.String">
        <value>红旗CA72</value>
    </constructor-arg>
    <constructor-arg type="double">
        <value>20000</value>
    </constructor-arg>
    <!--Car
Bean中必须有和此处一致的构造函数（String、double参数的构造函数）-->
</bean>

 ②ByIndex：

<!--构造注入-索引匹配入参-->
<bean id="carIndex" class="com.smart.injection.Car">
    <!--索引从0开始-->
    <constructor-arg index="0" value="红旗CA72"/>
    <constructor-arg index="1" value="中国一汽"/>
    <constructor-arg index="2" value="20000"/>
    <!-- 必须有一个3个入参的构造函数,如果不止一个，将以最后一个构造函数为准 -->
</bean>

 ③ByTypeIndex：

<!--构造注入-类型、索引 联合匹配入参--><bean id="carTypeIndex" class="com.smart.injection.Car"><constructor-arg index="0" type="java.lang.String"><value>红旗CA72</value></constructor-arg><constructor-arg index="1" type="java.lang.String" value="中国一汽"/><!-- constructor-arg两种格式均可 -->    <!-- int、double直接写，不加java.lang，否则异常Could not resolve matching constructor (hint: specify index/type/name arguments for simple parameters to avoid type ambiguities) --><constructor-arg index="2" type="double"><value>20000</value></constructor-arg></bean>
 ④ByReflection：


<!-- 构造注入-自身类型反射reflection --><bean id="office" class="com.smart.injection.Office"/><bean id="boss" class="com.smart.injection.Boss"><!--未设置type、index，通过入参值的类型完后匹配映射--><constructor-arg><value>xiaofan</value></constructor-arg><!--ref引用现有bean--><constructor-arg><ref bean="car"/></constructor-arg><constructor-arg><ref bean="office"/></constructor-arg></bean>


3）循环依赖问题


        Spring容器顺利实例化以构造函数方式配置的Bean的前提是：Bean构造函数引用的对象已经就绪。

如果两个Bean均通过构造函数注入，且通过构造函数入参引用对方，就会发生类似线程死锁的循环依赖问题。


<bean id="boss" ……ref="car">




<bean id="car" ……ref="boss">


因为循环依赖问题，Spring容器无法启动，将构造函数注入方式调整为属性注入即可。




2.3.3 注入参数详解








    

  • ①字面值--可通过<value>元素标签注入
    • 



字面值一般指可用字符串表示的值，如基本数据类型及其封装类、String。Spring内部编辑器可将以字符串表示的字面值转化为内部变量的相应类型。

特殊处理标签：

<![CDATA[ str ]]>，作用是让XML解析器将标签中的字符串当做普通文本对待，防止某些字符串对XML格式造成破坏。


<value><![CDATA[红旗CA72]]></value>




    

  • ②引用其他Bean--<ref>
    • 




<ref bean="car"/>


<ref>元素引用Bean的3个属性：


    bean：引用同一容器或父容器的Bean，最常见。


    local：只能引用同一配置文件的Bean，可利用XML解析器自动检验引用的合法性。


    parent：引用父容器的Bean。


    

  • ③集合类型属性
    • 



主要包括List、Set、Map、Properties。




<bean id="boss_list" class="com.smart.injection.Boss"><!--List属性既可通过value注入字符串，也可ref引用其他bean--><property name="list"><list><value>Java</value><value>Pathon</value></list></property></bean>


<bean id="boss_map" class="com.smart.injection.Boss"><property name="mapWeek"><map><entry><key><value>Mon</value></key><value>Reading</value></entry><entry><key><value>Tues</value></key><value>Sporting</value></entry><!-- 如果Map元素的键和值都是对象，可以ref            <entry>                <key><ref bean="keyBean"/></key>                <ref bean="valueBean"/>            </entry> --></map></property></bean><bean id="boss_pro" class="com.smart.injection.Boss"><!--Properties键值只能是字符串，值的配置没有value标签--><property name="type"><props><prop key="IDE">IDEA</prop><prop key="SQL">MySQL</prop></props></property></bean>


    

  • ④通过util命名空间配置集合类型的Bean
    • 




<!--需在Spring配置文件引入util命名空间--><util:list id="list_util" list-class="java.util.LinkedList"><value>Coding</value><value>Walk</value><!--Set类似--></util:list><util:map id="map_util"><entry key="Wed" value="Java"/><entry key="Thu" value="Spring"/></util:map><!-- <util:list>和Set支持value-type属性；Map支持key-type和value-type属性，指定键值类型 -->


    

  • ⑤简化配置方式
    • 




<!--简化XML配置：采用属性而非子元素配置信息--><!--Spring从2.5开始引入p命名空间，使用前需声明xmlns:p="http:~schema/p"--><bean id="car" class="com.smart.injection.Car"p:brand="红旗CA72"p:maxSpeed="260"/><bean id="boss" class="com.smart.injection.Boss"p:car-ref="car"/>




    

  • ⑤自动装配 autowire=“<自动装配类型>”
    • 



Spring IoC容器了解容器中所有的Bean信息，通过Java反射机制获知实现类的结构信息，开发人员可按照规则进行Bean的字段装配。


Spring提供了4种自动装配类型。<beans>元素标签中的default-autowired属性可配置为全局自动匹配，默认为0，表示不启用自动装配。其他可选配置如下图，byName，byType，constructor，autodetect。




减轻配置工作量，但造成配置文件Bean间关系不清楚，易引发潜在错误，因此实际项目建议少用。




2.3.4 Bean作用域


Spring2.0前仅有2个作用域：singleton和prototype。2.0开始针对WebApplicationContext新添了3个作用域。




Spring低版本由于只有2个作用域，So采用singleton=“true|false”的配置方式，为向后兼容，现依旧可用。


Spring新配置方式：scope=“<作用域类型>”


<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>


除以上5种，Spring还允许用户自定义Bean的作用域。org.springframework.beans.factory.config.Scope接口定义新作用域，再通过org。springframework.beans.factory.config.CustomScopeConfigurer这个BeanFactoryPostProcessor注册自定义的Bean作用域。【很少需要用户自定义作用域，自带的足以满足大部分需求】


2.3.5 基于注解的配置


1）使用注解定义Bean


基于XML的配置，Bean定义信息和Bean实现类本身分离；


基于注解的配置，Bean定义信息通过在Bean实现类上标注注解实现。


@Component("userDao")


    public class UserDao{……}


等价于一下XML配置：


<bean id="userDao" class="com.smart.UserDao"/>


除@Component外，Spring还提供3个功能基本和其等效的注解，也称为Bean的衍型注解。


@Repository：标注Dao实现类


@Service：标注Service实现类


@Controller：标注Web层的Controller实现类衍型注解让注解本身用途清晰化，也被Spring赋予了一些特殊的功能。【推荐使用】


2）使用注解配置信息启动Spring容器
Spring2.5后提供了context命名空间，提供了提供扫描包以应用注解定义Bean的方式。


使用方式：


a、声明context命名空间，xmlns:context="http://www.springframework.org/schema/context"


 b、扫描类包以应用注解定义的Bean，<context:component-scanbase-package="com.smart.anno">


context的命名空间的component-scan的base-package属性指定一个需要扫描的基类包，Spring将扫描此基类包的所有类，并从注解信息中获取Bean信息。


c、resource-pattern：过滤出特定类，仅扫描特定类而非基类包下的所有类。


<context:component-scanbase-package="com.smart" resource-pattern="anno/*.class">


resource-pattern属性默认值为“**/*.class”，即基类包里的所有类。此处设置为"anno/*.class"，Spring仅会扫描基类包anno子包中的类。


d、<context:component-scan>过滤子元素，如仅过滤基类包中实现了XXXService接口的类或标注了某个特定注解的类等，而resource-pattern仅可按资源名称过滤。


<context:component-scan base-package="com.smart">        <context:include-filter type="regex" expression="com\.smart\.anno.*"/>        <context:exclude-filter type="aspectj" expression="com.smart..*Controller+"/></context:component-scan>


<context:include-filter>表示要包含的类，<context:exclude-filter>表示要排除的类；一个component-scan下可包含若干个exclude和include。且这两个过滤元素均支持多种类型的过滤表达式。


过滤类型中，除custom外，aspectj过滤表达能力最强，可轻易实现其他类型所表达的过滤规则。




3）自动装配Bean【@Autowired】


@Service //定义一个Service，将UserService标注为一个Beanpublic class UserService {// 注入UserDao这个Dao层的Bean@Autowired


private UserDao userDao;


}


@Autowired：默认按类型匹配，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。


    

  • ①@Autowired的requried属性
    • 



若容器中没有和按标注类型匹配的Bean，Spring将抛出NoSuchBeanDefinitionException异常，如果希望即使找不到匹配的Bean也不要抛出异常，可使用@Autowired(required = false)进行标注。【required默认值为true】


    

  • ②@Qualifier指定注入Bean的名称
    • 



如果有超过一个匹配的Bean，可通过@Qualifier注解限定Bean的名称。


@Autowired


@Qualifier("userDao") //①


private UserDao userDao;


假设容器有两个类型UserDao的Bean，一个名为UserDao，一个名为UserDao2，则①处会注入名为UserDao的Bean。


    

  • ③标注类方法
    • 



@Autowired 可标注类成员变量及方法的入参，亦可标注类。


@Autowired //自动将LogDao传给方法入参


public void setLogDao(LogDao logDao) {


    this.logDao = logDao;


}


@Autowired // 自动将，名为UserDao的Bean传给方法入参


@Qualifier("userDao")


public void setUserDao(UserDao userDao) {


    this.userDao = userDao;


}


如果一个方法拥有多个入参，默认情况下，Spring自动选择匹配入参类型的Bean进行注入，Spring允许使用@Qualifier指定注入入参的Bean的名称。


@Autowired


public void init(@Qualifier("userDao")UserDao userDao,LogDao logDao){


     this.userDao = userDao;


     this.logDao =logDao;


}


以上例子，UserDao的入参注入名为UserDao的Bean，而LogDao的入参注入LogDao类型的Bean。


Note：


通常，Spring容器的大部分Bean是单实例，So无需通过@Repository、@Service等注解的value属性指定名称，也无需使用@Qualifier按名称注入。


    

  • ④标注集合类
    • 



Spring将容器中所有类型为Plugin的Bean注入这个变量中。


@Componentpublic class MyComponent {@Autowired(required = false)private List<Plugin> plugins;

public List<Plugin> getPlugins() {return plugins;    }}


此处，Plugin为接口，有两个实现类且两个实现类都通过@Component标注为Bean，So Spring会将这两个Bean都注入plugins。


2.3.6 基于Java类的配置


1）使用Java类提供Bean定义信息


@Configuration// 此注解说明此类可用于为Spring提供Bean的定义信息


public class AppConf {


    @Bean // 将一个POJO标注为定义Bean的配置类


    public UserDao userDao() {


        return new UserDao();


    }


    @Bean // Bean类型由方法返回值类型决定，名称默认和方法名相同，亦可显示指定。


    public LogDao logDao() {


        return new LogDao();


    }


    @Bean(name="LogonService")


    public LogonService logonService() {


        LogonService logonService = new LogonService();


        logonService.setLogDao(logDao()); // 注入上面定义的Bean


        logonService.setUserDao(userDao());


        return logonService;


    }


}


以上配置等价于


<bean id="userDao" class="com.smart.anno.UserDao"/>


<bean id="logDao" class="com.smart.anno.LogDao"/>


<bean id="logonService" class="com.smart.conf.LogonService"


     p:logDao-ref="userDao" p:userDao-ref="logDao"/>


对比：


基于Java类的配置方式：更灵活地实现Bean的实例化及Bean之间的装配；


XML或基于注解：    通过配置声明，灵活性略逊，但配置更简单。


@Configuration


public class DaoConfig {


    @Bean


    public UserDao userDao(){


        return new UserDao();


    }


    @Scope("prototype")


    @Bean


    public LogDao logDao(){


        return new LogDao();


    }


}


------------------------


@Configuration


public class ServiceConfig {


    @Autowired


    private DaoConfig daoConfig;


    @Bean


    public LogonService logonService() {


        LogonService logonService = new LogonService();


        System.out.println(daoConfig.logDao() == daoConfig.logDao());


        logonService.setLogDao(daoConfig.logDao()); //A、像普通Bean一样调用其他Bean方法


        logonService.setUserDao(daoConfig.userDao());


        return logonService;


    }


}


    

  • @Configuration注解类本身相当于标注了@Component，即可像普通Bean一样被注入其他Bean中（可直接调用@Configuration中标注@Bean的方法，如上）。
    • 



    

  • Spring对配置类所有标注@Bean的方法进行AOP增强，将对声明周期的逻辑植入进来。
    • 

  • A处调用daoConfig.logDao()逻辑：从Spring容器返回相应Bean的单例，即多次调用daoConfig.logDao()返回的都是相同Bean。Bean若标注@Scope("prototype")，则每次返回新的Bean。
    • 



2）直接通过@Configuration类启动Spring容器


// 使用@Configuration类中提供的Bean定义信息启动Spring容器


ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConf.class); //直接传入@Configuration标注的Java类


LogonService logonService = ctx.getBean(LogonService.class);


注：


AnnotationConfigApplicationContext支持加载多个配置类


 


//2.通过编码方式注册配置类


AnnotationConfigApplicationContext ctx2 = new AnnotationConfigApplicationContext();


ctx2.register(DaoConfig.class);


ctx2.register(ServiceConfig.class);


ctx2.refresh(); //刷新容器以应用这些注册的配置类


 //3.@Import将多个配置类组装到一个配置类中，仅需注册这个组装好的配置类即可启动容器。


@Configuration


@Import(DaoConfig.class)


public class ServiceConfig {


    @Autowired


    private DaoConfig daoConfig;


    @Bean


    public LogonService logonService() {


        LogonService logonService = new LogonService();


        return logonService;


    }


}


3）XML配置文件引用@Configuration的配置


// 通过上下文扫描加载到AppConf的配置类


<context:component-scan base-package="com.smart.conf"


        resource-pattern="AppConf.class" />


4）通过Configuration配置类引用XML配置信息


beans3.xml:


<bean id="userDao" class="com.smart.conf.UserDao"/>


-----------------


@Configuration@ImportResource("classpath:com/smart/conf/beans3.xml")  //自动注入XML文件中定义的Beanpublic class LogonAppConfig {@Bean  // 定义一个LogonService的Bean    @Autowired  // 通过入参自动注入UserDao和LogDao的Beanpublic LogonService logonService(UserDao userDao, LogDao logDao) {        LogonService logonService = new LogonService();        logonService.setUserDao(userDao);        logonService.setLogDao(logDao);return logonService;    }}


2.3.7 基于XML、注解、Java类三种配置方式的比较






通常基于Java类的方式使用较少。
				


				
时间： 2024-11-08 22:31:03

		
		


		


	

	
	

		


		
2.3 Bean装配的相关文章


								

		

			

                Spring三种bean装配方案
			

		

		

									

				首先来个简单且古老的Java类吧 public class SpringBean { public void say(){ System.out.println("这是一个SpringBean"); } } 1.当然了,第一种必须是我们最智能话的装配方案,自动装配了. 在自动装配的时候,需要保证对类进行注解操作. @Component//一种通用的组件描述 @Controller//通常用于web中的控制器组件上 @Service//通常用于service服务组件上 @Reposito			

		

	

				

		

			

                Spring Bean装配&amp;#183;Aware&amp;#183;Resource
			

		

		

									

				作用:实现了Aware接口的bean在初始化后可以获取相应资源并进行相应的操作 举例: ApplicationContextAware:向实现了该接口的bean提供IOC容器的上下文信息(ApplicationContext),实现了该接口的bean必须配置到配置文件中并由spring的bean容器加载 BeanNameAware:向实现了该接口的bean提供关于beanName定义的相关内容 其他就做不介绍了,官网文档内容如下: Table 7.4. Aware interfaces Name			

		

	

				

		

			

                装配Bean
			

		

		

									

				1.创建Spring配置 在XML文件中声明Bean时,spring配置文件的根元素来源于Spring beans命名空 间所定义的<beans>元素.以下为一个典型的Spring XML配置文件: [html] view plain copy  print? <span style="color:#009900;"><?xml version="1.0" encoding="utf-8"?>   <be			

		

	

				

		

			

                Spring实战3：装配bean的进阶知识
			

		

		

									

				主要内容: Environments and profiles Conditional bean declaration 处理自动装配的歧义 bean的作用域 The Spring Expression Language 在装配bean-依赖注入的本质一文中,我们探讨了Spring的三种管理bean的方式:自动装配.基于JavaConfig.基于XML文件.这篇文字将探讨一些Spring中关于bean的管理的高级知识,这些技能你可能不会每天都用,但是非常重要. 3.1 Environments			

		

	

				

		

			

                《Spring实战（第4版）》——2.4　通过XML装配bean
			

		

		

									

				2.4 通过XML装配bean 到此为止,我们已经看到了如何让Spring自动发现和装配bean,还看到了如何进行手动干预,即通过JavaConfig显式地装配bean.但是,在装配bean的时候,还有一种可选方案,尽管这种方案可能不太合乎大家的心意,但是它在Spring中已经有很长的历史了. 在Spring刚刚出现的时候,XML是描述配置的主要方式.在Spring的名义下,我们创建了无数行XML代码.在一定程度上,Spring成为了XML配置的同义词. 尽管Spring长期以来确实与XML有着			

		

	

				

		

			

                Spring实战2：装配bean—依赖注入的本质
			

		

		

									

				主要内容 Spring的配置方法概览 自动装配bean 基于Java配置文件装配bean 控制bean的创建和销毁 任何一个成功的应用都是由多个为了实现某个业务目标而相互协作的组件构成的,这些组件必须相互了解.能够相互协作完成工作.例如,在一个在线购物系统中,订单管理组件需要与产品管理组件以及信用卡认证组件协作:这些组件还需要跟数据库组件协作从而进行数据库读写操作. 在Spring应用中,对象无需自己负责查找或者创建与其关联的其他对象,由容器负责将创建各个对象,并创建各个对象之间的依赖关系.例如			

		

	

				

		

			

                《Spring攻略（第2版）》——1.11　用XML配置自动装配Bean
			

		

		

									

				1.11 用XML配置自动装配Bean 1.11.1 问题 当一个Bean需要访问另一个Bean时,你可以显式指定引用装配它.但是,如果你的容器能够自动装配Bean,就可以免去手工配置装配的麻烦. 1.11.2 解决方案 Spring IoC容器能够帮助你自动装配Bean.你只要在的autowire属性中指定自动装配模式就可以了.表1-2列出了Spring支持的自动装配模式. *默认模式是no,但是可以设置根元素的default-autowire属性修改.这个默认模式将被Bean自己指定的模式覆			

		

	

				

		

			

                《Spring实战（第4版）》——2.2　自动化装配bean
			

		

		

									

				2.2 自动化装配bean 在本章稍后的内容中,你会看到如何借助Java和XML来进行Spring装配.尽管你会发现这些显式装配技术非常有用,但是在便利性方面,最强大的还是Spring的自动化配置.如果Spring能够进行自动化装配的话,那何苦还要显式地将这些bean装配在一起呢? Spring从两个角度来实现自动化装配: 组件扫描(component scanning):Spring会自动发现应用上下文中所创建的bean.自动装配(autowiring):Spring自动满足bean之间的依赖			

		

	

				

		

			

                Spring中bean的基本xml配置
			

		

		

									

				xml   在spring容器内拼凑bean叫作装配.装配bean的时候,你是在告诉容器,需要哪些bean,以及容器如何使用依赖注入将它们配合在一起.    理论上,bean装配可以从任何资源获得,包括属性文件,关系数据库等,但xml是最常见的spring 应用系统配置源.Spring中的几种容器都支持使用xml装配bean,包括:    XmlBeanFactory ,    ClassPathXmlApplicationContext ,    FileSystemXmlApplicatio