Spring IoC容器（基础知识点+XML配置）

参考/摘录书籍：Spring+Spring MVC+MyBatis整合开发 著○陈学明
参考图片：来自网络
说明：本人相关博客仅供学习参考！

一、相关概念

1.1 IoC和DI

   IoC（Inversion of Control，控制反转） 容器是Spring最核心的概念和内容。它替代了传统的new方式初始化对象，通过读取在XML文件中配置的Bean定义，自动创建并管理容器的Bean实例及生命周期 。
控制权的转移即所谓的反转，依赖对象创建的控制权从应用程序本身转移到外部容器。控制反转的实现策略一般有两种：

• 依赖查找（Dependency Lookup）
• 依赖注入（Dependency Injection）：依赖对象通过注入进行创建。由容器负责组件的创建和注入，这是更为流行的IoC实现策略，根据配置将符合依赖关系的对象传递给需要的对象。

IoC是一种软件设计思想，DI是这种思想的一种实现。控制反转乃至依赖注入的目的不是提升系统性能，而是提升组件重用性和系统的可维护性。
Spring IoC容器用来创建和管理类的实例称为Bean。

1.2 JavaBean、POJO对象

  JavaBean是JCP定义的一种Java类的标准，包括属性、方法和事件三方面的规范。

• public修饰的类
• 该类含有无参构造函数
• 该类需要被序列化且实现Serializable接口
• 可有一些列的读写属性（getter或setter方法）

1.public修饰是为了提供给其他类使用。
2.无参构造器是为了让框架和容器可以通过反射机制来进行实例化。
3.实现Serializable接口是为了可以序列化和反序列化，以便进行对象的传输或保存。

  POJO（简单Java对象）

• 没有继承任何类
• 没有实现任何接口

二、Spring容器初始化

  Spring IoC容器用来创建和管理类的实例称为Bean。本剧Bean的配置，使用Bean工厂（BeanFactory接口实现类的对象）创建和管理Bean实例。除了创建和管理Bean实例，Spring容器最重要的作用是根据配置注入依赖对象。
  BeanFactory和ApplicationContext是Spring进行对象管理的两个主要接口。
基于Spring框架的应用在启动时会根据配置创建一个实现BeanFactory接口的类对象，这个对象就是所谓的容器。
  ApplicationContext是IoC容器的另一个重要接口，被称为应用上下文，它继承自BeanFactory，包好了BeanFactory的所有功能，同时还提供了一些新的高级功能。如

• MessageSource（国际化资源接口），用于信息的国际化显示。
• ResourceLoader（资源加载接口），用于资源加载。
• ApplicationEventPublisher（应用时间发布接口），用于应用事件的处理。

BeanFactory要在代码里写出来才可以被容器识别，而ApplicationContext是直接配置在配置文件即可。

2.1 引入依赖

<!-- 引入Spring依赖 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.2.6.RELEASE</version>
</dependency>

2.2 创建Spring配置文件

  在类路径下创建一个任意名称的xml 文件。【这里名称为：beans.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"
       xsi:schemaLocation="
       		http://www.springframework.org/schema/beans
       		http://www.springframework.org/schema/beans/spring-beans.xsd
       		">
<!-- xmlns 是XML Namespace的缩写，即XML命名空间 -->
<!-- xmlns:xsi 表示使用xsi作为前缀的命名空间，这个属性是为了下面的xsi:schemaLocation的定义 -->
<!-- xsi:schemaLocation 用于定义命名空间和对应的XSD（XML结构定义）文档的文职关系，两者是成对匹配的 -->

<!-- 从Spring2.5开始支持基于注解的配置；
	 从Spring3.0开始支持直接使用Java代码进行配置； -->
<!-- 一般将service、dao、pojo层的对象交由容器管控 -->

	<!-- 使用bean标签来配置一个Bean对象，spring会把此对象存到IoC容器中
		【默认情况下，容器根据每个Bean的配置创建和维护一个单例对象】
	     id ：给这个类的对象一个表示，以方便容器和程序查找和使用【如果不设定id的属性和值，则容器默认会以类名的首字母小写作为标识】
	     class ：类的全限定名
	 -->
	<bean id="userDao" class="com.ccbx.dao.impl.UserDaoImpl"></bean>
	<bean id="userService" class="com.ccbx.service.impl.UserServiceImpl"></bean>
</beans>

2.3 ApplicationContext初始化方式

  在Spring中，使用“classpath:”来表示类的根路径；“classpath*:”来表示出了自身的类路径之外，还会查找依赖库（.jar）下的目录。
  类路径 是指编译后的class文件的目录，在web项目中是WEB-INF/classes目录。


此时使用ac.getBean(“userDao”);即可获得容器中创建的实例对象；

(1) 配置文件位于项目的类的根路径下
//方式1：使用类路径应用上下文初始化类
ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
//方式2：使用文件路径应用上下文初始化类
ApplicationContext context= new FileSystemXmlApplicationContext("classpath:applicationContext.xml");
(2) 配置文件位于项目的根路径下
ApplicationContext context= new FileSystemXmlApplicationContext("applicationContext.xml");

2.4 测试

//从spring容器中获取需要的对象
// 1.加载类路径下的spring的xml配置文件，获取Spring容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
//2.从容器中获取对象，根据名称来获取
UserDao userDao = (UserDao) ctx.getBean("userDao");
System.out.println(userDao);
UserService userService = (UserService) ctx.getBean("userService");
System.out.println(userService);

三、Bean标签和管理对象

3.1 Bean标签

  使用类的名字在XML中配置Bean，并给这个Bean设置一个标识，容器基于配置来创建相应的类的对象，之后就可以通过标识（也可以通过类）从容器中获取该对象，实现所谓的容器对Bean的托管。
作用：用于配置让 spring来创建对象的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性:

• id： 给对象在容器中提供一个唯一标识。用于获取对象。
• class： 指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
• scope： 指定Bean所托管的对象的作用域范围。【Bean的作用域配置在Spring中指定的是当前配置创建的Bean相对于其他Bean的可见范围】
  1、singleton ：默认值，单例作用域。【Spring IoC容器只创建和维护一个该类型的Bean实例，并将这个实例存储到单例缓存(singleton cache)中，针对该Bean的请求和引用，使用的都是同一个实例。只要容器没有退出或者销毁，该类型的单一实例就会一直存活。】
  2、prototype ：原型作用域。【原型作用域的Bean在使用容器的getBean( )方法获取的时候，每次得到的都是一个新的对象，作为依赖对象注入到其它Bean的时候也会产生一个新的类对象。（容器不负责原型作用域Bean实例的完整声明周期，不需要的时候需要手动释放）】
  3、request ：请求作用域。针对每次HTTP请求，Spring都会创建一个Bean实例。WEB项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中。
  4、session ：会话作用域。使用于HTTP Session，同一个Session共享同一个Bean实例。WEB项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中。
  5、application ：应用作用域。整个Web应用，也就是在ServletContext生命周期中使用一个Bean实例。
  6、websocket：websocket作用域的配置是在一个WebSocket连接的生命周期中共用一个Bean实例。
• parent：该属性可以从父Bean继承配置数据。

情景1：
<!-- Spring支持Bean的继承，Bean的继承用于Bean实例之间的参数值的延续； -->
<!-- 父bean包含name属性 -->
<bean id="parentBean" class="com.ccbx.pojo.ParentBean">
	<property name="name" value="张三" />
</bean>
<!-- 使用继承配置，子Bean的name的值从父Bean继承 -->
<bean id="childBean" class="com.ccbx.pojo.ChildBean" parent="parentBean">
	<property name="age" value="18" />
</bean>
<!-- 此时，childBean实例的属性值就包含了子Bean和父Bean的所有依赖注入（name和age） -->

情景2：
<!-- 
	1.如果父Bean仅仅是作为一个配置末班的话，则可以设置父Bean的abstract属性为true，容器就不会实例化这个Bean。
	2.作为模板的父Bean可以不指定class属性，但需要指定abstract="true" ；
	3.如果父Bean制定了class属性，子Bean可以不指定class属性，此时子Bean使用的就是父Bean的class属性；
	-->
<bean id="parentBean" abstract="true"><!--抽象父bean作为属性值模板-->
	<property name="name" value="张三" />
</bean>

• init-method： 指定Bean在初始化时回调的方法【该托管的类中的方法】。
• destroy-method： 指定Bean在初始化时回调的方法【该托的管类中的方法】。
• lazy-init：设置为true表示获取对象时才去创建对象(延迟加载)【默认为false：主动加载】

<!-- 全局懒加载【不推荐】(在配置文件根元素<beans>中设置属性default-lazy-init的值) -->
<beans default-lazy-init="true" ></beans>

<!-- 个别懒加载【推荐】 -->
<beans id="helloService" class="com.ccbx.service.HelloService" lazy-init="true" />
<!--lazy-init的取值可有3种：
	default : 从default-lazy-init继承；
	true : 懒加载；
	false : 非懒加载；【不写lazy-init属性也是非懒加载】
	
	【注意】
		1.对于prototype作用域的Bean，lazy-init的配置无效，始终是懒加载！
		2.懒加载Bean不会在容器初始化的时候就创建，而是使用getBean()方法获取该Bean实例时创建！
		3.如果某个懒加载Bean作为依赖注入其它非懒加载的Bean时，此时容器在初始化的时候就会创建该懒加载Bean的实例！
-->

3.2 实例化Bean的方式

第一种方式:使用无参构造方法【重点掌握】

//Spring创建对象的时候默认都是调用类的无参构造器
public UserDaoImpl(){
	//当我们调用getBean()获取容器中的对象时该构造方法被调用
	System.out.println("UserDaoImpl对象创建了！");
}

第二种方式:使用静态工厂的方法创建对象

//第一步：创建静态工厂的类
public class StaticFactoryService{
	//声明静态变量
	private static StaticFactoryService service = new StaticFactoryService();
	//静态方法，返回该类的静态实例
	public static StaticFactoryService getInstance(){
		return service;
	}
}

使用Spring配置时，除了需要制定Bean的id和class属性之外，还要使用factory-method属性制定获取静态对象的方法，配置如下：

<!-- 静态方法的Bean定义 -->
<bean id="staticFactoryService" class="com.ccbx.utils.StaticFactoryService" factory-method="getInstance" />

第三种方式:使用实例工厂的方法创建对象

//普通的JavaBean类
public class Foo {
}

//含有工厂方法的类
public class InstanceFactory {
    private static Foo foo = new Foo();
    //工厂方法【获取目标类的实例化对象】
    public Foo getFooInstance(){
        return foo;
    }
}

<!-- 配置文件中需要配置工厂类的Bean和目标类的Bean -->
<!--目标对象的Bean-->
<bean id="instanceFactory" class="com.ccbx.factory.InstanceFactory" />
<!--工厂类的Bean【使用工厂类的方法实现目标类的Bean】-->
<bean id="foo" factory-bean="instanceFactory" factory-method="getFooInstance" />

在现实情况中，工厂类一般用来对多个不同的目标类实例化，对应不同的实例化方法，相应的只需要增加对应的配置（bean标签）即可。

3.3 Bean标签总结

分类	属性名	说明
属性配置	id	Bean标识，默认类名首字母小写
↑	class	Bean对应的Java类，一般情况下是必要的，实例工厂方式不需要
↑	scope	作用域配置，默认为 singleton
↑	autowire	自动装配
↑	parent	定义继承
↑	lazy-init	懒加载
↑	init-method	初始化方法
↑	destroy-method	销毁方法
↑	factory-bean	实例工厂配置使用
↑	factory-method	静态工厂和实例工厂配置使用
元素	property	属性依赖注入name、ref 和 value
↑	constructor-arg	构造器依赖注入name、ref 和 value
↑	replaced-method	方法替换

四、依赖注入

4.1 构造函数注入

  顾名思义，就是使用类中的带参构造函数，给成员变量赋值。赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。

无参构造函数注入【默认】：

注意：
  如果显示声明了有参构造器的话，无参构造器会被覆盖，此时需要显式声明无参构造函数。否则依赖无参构造函数注入的Bean就会报错！

有参构造函数注入：

< constructor-arg >标签

属性	描述
name	构造函数中对应参数的名称
type	构造函数中对应参数的数据类型
index	指定参数在构造函数参数列表的索引位置（从0开始）
value	给指定参数赋值（它能赋值的类型为：基本数据类型，String类型）
ref	引用其它的bean类型，作为参数的值（所引用的bean必须是在配置文件中配置了的）

4.2 set注入

  设置值注入使用的是属性的setter方法来注入依赖对象。【依赖无参构造函数】

< property >标签

属性	描述
name	是setXxx方法中的xxx【调用xxx属性的set方法实现注入】
value	给相应的属性赋的简单类型的值
ref	引用其它的bean类型，作为参数的值（所引用的bean必须是在配置文件中配置了的）

测试：

案例：
  简单类型作为依赖进行注入，在实际项目中可以用来做环境参数设置的配置类，或者做第三方类的配置信息的输入，类似于数据库连接的访问；
  为提高系统的灵活性和安全性，value的值不直接设置在配置中，而是使用占位符（也可以理解为变量）；

	<!-- 加载关于数据库连接的properties属性文件【引入多个配置文件时在location属性中逗号隔开即可】 -->
    <context:property-placeholder location="classpath:db.properties,classpath:otherdb.properties"/>
	<!-- 【配置Druid数据源】Spring容器加载时立即创建 DruidDataSource 的实例 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

  在类路径下配置 db.properties属性文件

#使用二级名称，避免SEL获取key时出错【例如：${jdbc.username}】
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?useSSL=false&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=123456

  使用< context >标签要引入context名称空间

<?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"
       xsi:schemaLocation="
	       http://www.springframework.org/schema/beans
	       http://www.springframework.org/schema/beans/spring-beans.xsd
	       http://www.springframework.org/schema/context
	       http://www.springframework.org/schema/context/spring-context.xsd
">
</beans>

4.3 c,p 名称空间注入

  使用c、p命名空间可以分别对构造器注入（constructor-arg）和属性注入（property）进行简写，即从定义子元素换成定义属性的方式。步骤如下：

首先需要将<beans>根元素加入响应的命名空间；

<?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:p="http://www.springframework.org/schema/p"
       xmlns:p="http://www.springframework.org/schema/c"
       xsi:schemaLocation="
       		http://www.springframework.org/schema/beans
        	http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 【注】xsi:schemaLocation不需要加入文档结构的定义，因为这还是属于Bean元素的定义。 -->

</beans>

  c命名空间注入

  【只需要在<bean>增加：c:构造参数名=“值”】

<!-- 简单类型的构造器注入 -->
<bean id="bookBean10" class="com.ccbx.pojo.Book" c:name="《c名称空间注入》" c:parent-ref="currentDate" p:price="16.5" lazy-init="true"/>

如果注入的依赖是对象类型，则在参数名后加上-ref即可，值对应的就是Bean的id[c、p命名空间可以混用]。

  p命名空间注入

  此种方式是通过在 xml 中导入 p 名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用类中的set 方法实现注入功能。

<!-- 导入了p名称空间后，可直接用p:xxx=yyy方式或者p:xxx-ref=yyy方式来注入 -->
<bean id="bookBeanByPSpace" class="com.ccbx.pojo.Book"
          p:id="2" p:name="《p名称空间注入》" p:price="10.0" p:publishDate-ref="currentDate" lazy-init="true"/>

4.4 数组类型依赖注入

  类中的集合和数组成员传值，它用的也是基于set方法注入。

	<bean id="bookBean6" class="com.ccbx.pojo.Book" lazy-init="true">
        <property name="id" value="20"/>
        <property name="name" value="《Map集合注入》"/>
        <property name="bookId">
            <!-- 使用array配置一个数组，注入给类里的数组属性 -->
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
    </bean>

4.5 集合类型依赖注入

  类中的集合和数组成员传值，它用的也是基于set方法注入。

4.5.1 List集合注入

测试代码：
//要从spring容器中获取需要的对象，先要获取Spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");

//List集合注入测试
@Test
public void test6(){
    Book bookBean5 = ac.getBean("bookBean5", Book.class);
    lg.debug("List集合注入创建Book实例:"+bookBean5);
    List<String> bookNameList = bookBean5.getBookNameList();
    for (String n : bookNameList) {
        lg.debug(n);
    }
}

注意：
  如果List集合中的元素是其它Bean类型(除了简单类型以外的),该如何注入这种复杂Bean类型元素的List集合？
  在beans.xml中配置List集合，集合中需要添加元素，可以用<bean>标签或<ref>标签添加复杂Bean类型元素；

	<bean id="bookBean6" class="com.ccbx.pojo.Book" lazy-init="true">
        <property name="id" value="20"/>
        <property name="name" value="《Map集合注入》"/>
        <property name="addressList">
		    <list>
		        <!-- 使用ref标签向集合中注入一个Bean对象 -->
		        <ref bean="address1" />
		        <!-- 使用bean标签向集合中注入一个Bean对象 -->
		        <bean id="addresds2" class="com.java.pojo.Address">
		            <property name="name" value="湖北" />
		        </bean>
		    </list>
		</property>
    </bean>

4.5.2 Map集合注入

测试代码：

//map集合注入测试
@Test
public void test5(){
//从spring容器中获取需要的对象
//步骤1：加载类路径下的spring的xml配置文件，获取Spring容器
	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    Book bookBean4 = ac.getBean("bookBean4", Book.class);
    lg.debug("Map集合注入创建Book实例:"+bookBean4);
    Map<Integer, String> bookIdMap = bookBean4.getBookIdMap();
    Set<Map.Entry<Integer, String>> entries = bookIdMap.entrySet();
    for (Map.Entry<Integer, String> entry : entries) {
        lg.debug("id:"+entry.getKey()+",bookName:"+entry.getValue());
    }
}

4.5.3 Properties集合注入

  <props>对应的是java.util.Properties的对象，用来配置字符串类型的键和值的属性，可以看成是对<map>的简化。使用<prop>子元素的key指定键，子元素的内容为值。

	<bean id="bookBean7" class="com.ccbx.pojo.Book" lazy-init="true">
        <property name="animals">
            <!-- 使用props标签来配置一个Properies集合，里面每个prop代表键值对，即给Properies集合注入值 -->
            <props>
                <!-- prop配置键值对 -->
                <prop key="id">111</prop>
                <prop key="name">大象</prop>
                <prop key="age">52</prop>
            </props>
        </property>
    </bean>

测试代码：

	@Test
    public void test07(){
        Book book = (Book) ac.getBean("bookBean7");
        Properties prop = book.getAnimals();
        //返回此哈希表中键的枚举
        Enumeration keys = prop.keys();
        //遍历key的枚举
        while(keys.hasMoreElements()){
            String key =(String) keys.nextElement();
            String value = prop.getProperty(key);
            System.out.println(("key:"+key+",value:"+value));
        }
    }

五、XML配置进阶

5.1 多XML配置文件

  使用import导入拆分的配置：

<!-- 主配置的根目录 -->
<beans>
	<!-- 导入服务类的配置 -->
	<import resource="services.xml" />
	<!-- 导入消息的配置 -->
	<import resource="resources/messageSource.xml" />
	<!-- 其它Bean的配置 -->
	<bean id="bean1" class="..." />
	<bean id="bean2" class="..." />
</beans>

import 也常被用来导入第三方包提供的配置。

5.2 BeanFactoryPostProcessor

  BeanFactoryPostProcessor是在容器初始化之后Bean实例化之前，在容器加载Bean 的定义阶段执行，此扩展点可以对Bean配置的元数据读取和修改，比如Bean的scope、lazy-init属性和依赖注入对象等。
  PropertyPlaceholderConfigure，这个类继承自BeanFactoryPostProcessor，其作用是对所有的Bean定义的占位符替换成对应的值。

案例如下：
将数据库连接信息配置到db.properties属性文件中；

#使用二级名称，避免SEL获取key时出错【例如：${jdbc.username}】
#数据库驱动
jdbc.driverClassName=com.mysql.jdbc.Driver
#MySQL数据源地址
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?useSSL=false&serverTimezone=GMT%2B8
#数据库用户名
jdbc.username=root
#密码
jdbc.password=123456

在Spring配置文件beans.xml中增加如下配置：

<!-- 占位符替换Bean定义，使用properties指定属性文件 -->
    <bean id="dbConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
		<property name="properties" value="classpath:db.properties" />
	</bean>
	<!-- 【配置Druid数据源】Spring容器加载时立即创建 DruidDataSource 的实例 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    	<!-- ${ }占位符 -->
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

【占位符的变量替换成值的步骤】

1. 配置PropertyPlaceholderConfigurer的Bean，依赖注入属性文件之后，在其他Bean的定义中就可以使用${变量名}这样的占位符注入简单类型。
2. 每个Bean初始化之前，会对每个Bean的定义做一次调整和修改，PropertyPlaceholderConfigurer将对应的变量替换成实际的值。这样在Bean实例化的时候使用的就是替换后的值。

5.3 自动装配

  使用构造器和属性注入的依赖项，需要在<bean>元素下手动配置需要注入的对象。Spring也提供了自动装配（autowire）的配置，可以省去依赖注入的配置。
【实际开发中经常使用@Autowired注解进行依赖的装配】

5.3.1 全局设定

  在beans根元素设置default-autowire的值可以开启整个应用中配置Bean的依赖自动注入，容器会根据default-autowire设置的匹配类型自动查找符合的Bean实例进行注入。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       		http://www.springframework.org/schema/beans
        	http://www.springframework.org/schema/beans/spring-beans.xsd"
        	default-autowire="byName" >
<!-- default-autowire="值"；该“值”有3种；通过这三种方式来查找依赖对象。
	byName : 根据Bean的标识（id、name和别名）
	byType : 类的类型
	constructor : 构造器中参数类型；-->

</beans>

全局设定对所有Bean会自动生效，如果希望某个Bean不作为依赖被其它Bean使用的话，可以在该Bean上设置autowire-candidate的属性值为false。

5.3.2 个别设定

  设置<bean>的autowire来指定依赖自动装配的方式，autowire可设置的值和全局的设定的值是相同的。

<bean id="bookBean" class="com.ccbx.pojo.Book" autowire="byName" />

参考详细自动装配（相关博客）