• spring学习总结——装配Bean学习三（xml装配bean）（spring基于xml的装配方式）
• Spring - 装配Bean
• spring 使用@Bean装配Bean
• spring 学习总结 —— 装配 Bean 学习一（自动装配）
• Spring 实战 通过XML装配Bean

spring学习总结——装配Bean学习三（xml装配bean）（spring基于xml的装配方式）

通过XML装配bean

　　Spring现在有了强大的自动化配置和基于Java的配置，XML不应该再是你的第一选择了。不过，鉴于已经存在那么多基于XML的Spring配置，所以理解如何在Spring中使用XML还是很重要的。但是，我希望本节的内容只是用来帮助你维护已有的XML配置，在完成新的Spring工作时，希望你会使用自动化配置和JavaConfig。

一、创建XML配置规范

　　在使用XML为Spring装配bean之前，你需要创建一个新的配置规范。在使用JavaConfig的时候，这意味着要创建一个带有@Configuration注解的类，而在XML配置中，这意味着要创建一个XML文件，并且要以<beans>元素为根。

最为简单的Spring XML配置如下所示：

很容易就能看出来，这个基本的XML配置已经比同等功能的JavaConfig类复杂得多了。作为起步，在JavaConfig中所需要的只是@Configuration，但在使用XML时，需要在配置文件的顶部声明多个XML模式（XSD）文件来约束格式，这些文件定义了配置Spring的XML元素。

二、声明一个简单的<bean>

　　要在基于XML的Spring配置中声明一个bean，我们要使用spring-beans模式中的另外一个元素：<bean>。<bean>元素类似于JavaConfig中的@Bean注解。

我们可以按照如下的方式声明CompactDiscbean：

这里声明了一个很简单的bean，创建这个bean的类通过class属性来指定的，它将会调用SgtPeppers的默认构造器来创建bean，并且要使用全限定的类名。借助id属性，为每个bean设置一个名字（在装配到其他bean的时需要根据准确的名字）。
补充：限定类名，就是类名全称，带包路径的用点隔开，例如: java.lang.String。非限定(non-qualified)类名也叫短名，就是我们平时说的类名，不带包的，例如：String。

三、借助构造器注入初始化bean

　　在Spring XML配置中，只有一种声明bean的方式：使用<bean>元素并指定class属性。Spring会从这里获取必要的信息来创建bean。但是，在XML中声明DI时，会有多种可选的配置方案和风格。具体到构造器注入，有两种基本的配置方案可供选择：

• <constructor-arg>元素
• 使用Spring 3.0所引入的c-命名空间

接下来，看一下它们各自如何注入bean引用。

1、构造器注入bean引用

例子场景：创建一个CDPlayer（CD播放器）的bean，需要有一个接收CompactDisc（CD盘）类型的构造器。

当Spring遇到这个<bean>元素时，它会创建一个CDPlayer实例。<constructor-arg>元素会告知Spring要将一个ID为compactDisc的bean引用传递到CDPlayer的构造器中。

c-命名空间

　　作为替代的方案，你也可以使用Spring的c-命名空间。c-命名空间是在Spring 3.0中引入的，它是在XML中更为简洁地描述构造器参数的方式。要使用它的话，必须要在XML的顶部声明其模式，如下所示：

在c-命名空间和模式声明之后，我们就可以使用它来声明构造器参数了，如下所示：

配置结构图：（这里粗略的讲解c-命名空间）

2、将字面量注入到构造器中

补充：字面量就是值 不声明变量储存。例如 int a = 0; a = a + 3;  a 是变量 3是字面量；

CompactDisc的一个新实现，有参构造函数的参数是基本类型（直接传字面量）而不是对象的引用时：

XML的配置：

c-命名空间：

3、装配集合

　　在装配bean引用和字面量值方面，<constructor-arg>和c-命名空间的功能是相同的。但是有一种情况是<constructor-arg>能够实现，c-命名空间却无法做到的。接下来，让我们看一下如何将集合装配到构造器参数中。

需求：如果使用CompactDisc为真正的CD建模，那么它也应该有磁道列表(tracks)的概念，每个磁道上包含一首歌。请考虑下面这个新的BlankDisc：

在声明bean的时候，我们必须要提供一个磁道列表。要达到这一点，我们可以有多个可选方案。首先，可以使用<list>元素将其声明为一个列表：

其中，<list>元素是<constructor-arg>的子元素，这表明一个包含值的列表将会传递到构造器中。其中，<value>元素用来指定列表中的每个元素。

与之类似，我们也可以使用<ref>元素替代<value>，实现bean引用列表的装配。例如，假设你有一个Discography类，它的构造器如下所示(集合泛型为对象引用)：

那么，你可以采取如下的方式配置Discography bean：

当构造器参数的类型是java.util.List时，使用<list>元素是合情合理的。尽管如此，我们也可以按照同样的方式使用<set>元素：

<set>和<list>元素的区别不大，其中最重要的不同在于当Spring创建要装配的集合时，所创建的是java.util.Set还是java.util.List。如果是Set的话，所有重复的值都会被忽略掉，存放顺序也不会得以保证。不过无论在哪种情况下，<set>或<list>都可以用来装配List、Set甚至数组。

四、设置属性

到目前为止，CDPlayer和BlankDisc类完全是通过构造器注入的，没有使用属性的Setter方法。接下来，我们就看一下如何使用Spring XML实现属性注入。假设属性注入的CDPlayer如下所示：

该选择构造器注入还是属性注入呢？作为一个通用的规则，我倾向于对强依赖使用构造器注入，而对可选性的依赖使用属性注入。现在，CDPlayer没有任何的构造器（除了隐含的默认构造器），它也没有任何的强依赖。因此，你可以采用如下的方式将其声明为

Spring bean：

Spring在创建bean的时候不会有任何的问题，但是CDPlayerTest会因为出现NullPointerException而导致测试失败，因为我们并没有注入CDPlayer的compactDisc属性。不过，按照如下的方式修改XML，就能解决该问题

<property>元素为属性的Setter方法所提供的功能与<constructor-arg>元素为构造器所提供的功能是一样的。在本例中，它引用了ID为compactDisc的bean（通过ref属性），并将其注入到compactDisc属性中（通过setCompactDisc()方法）

p-命名空间

Spring为<constructor-arg>元素提供了c-命名空间作为替代方案，与之类似，Spring提供了更加简洁的p-命名空间，作为<property>元素的替代方案。为了启用p-命名空间，必须要在XML文件中与其他的命名空间一起对其进行声明：

我们可以使用p-命名空间，按照以下的方式装配compactDisc属性：

 p-命名空间中属性所遵循的命名约定与c-命名空间中的属性类似。

将字面量注入到属性中

属性也可以注入字面量，这与构造器参数非常类似。作为示例，我们重新看一下BlankDisc bean，新的BlankDisc类如下所示：

我们需要装配这些属性，可以借助<property>元素的value属性实现该功能：

在这里，除了使用<property>元素的value属性来设置title和artist，我们还使用了内嵌的<list>元素来设置tracks属性；另外一种可选方案就是使用p-命名空间的属性来完成该功能：

与c-命名空间一样，装配bean引用与装配字面量的唯一区别在于是否带有“-ref”后缀。如果没有“-ref”后缀的话，所装配的就是字面量。

我们不能使用p-命名空间来装配集合，没有便利的方式使用p-命名空间来指定一个值（或bean引用）的列表。但是，我们可以使用Spring util-命名空间中的一些功能来简化BlankDiscbean。（不做详细说明）

Spring - 装配Bean

装配Bean

• 任何一个成功的应用都是由多个为了实现某个业务目标而相互协作的组件构成的
• 创建应用对象之间协作关系的行为通常称为装配(wiring)，这也是依赖注入(DI)

Spring配置的可选方案

• 在XML中进行显示配置
• 在Java中进行显示配置
• 隐式的bean发现机制和自动装配

自动化装配bean

• 组件扫描(component scanning)：Spring会自动发现应用上下文中所创建的bean
• 自动装配(autowiring)：Spring自动满足bean之间的依赖

设置组件扫描的基础包

• @ComponentScan：默认扫描当前所在的包
• @ComponentScan("soundsystem")：表明你所设置的是基础包
• @ComponentScan(basePackages="soundsystem")/@ComponentScan(basePackages={"soundsystem", "video"})：更清晰表明设置的基础包
• @ComponentScan(basePackageClasses={CDPlayer.class, DVDPlayer.class})：扫描这些类所在的包

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

/**
 * 自动扫描当前包下的@Component
 * 也可以启用 XML <context:component-scan base-package="com.leaf.u_spring.chapter02" />
 */
@Configuration
@ComponentScan
public class CDPlayerConfig {

    /**
     * 随机选择一个CompactDisc来播放
     * 这个例子可以看出@Bean的强大功能
     * 
     * 还可以指定名称
     */
    @Bean(name="randomDisc")
    public CompactDisc randomBeatlesCD(){
        int choice = (int) Math.floor(Math.random() * 4);
        if(choice == 0){
            return new SgtPeppers();
        } else if(choice == 1) {
            return null;
        } else if(choice == 2) {
            return null;
        } else {
            return null;
        }
        
    }
    
}

通过Java代码装配bean

• 显示配置，JavaConfig是更好的方案，因为它更为强大、类型安全并且对重构友好
• 构造器和Setter方法只是@Bean方法的两个简单样例

通过XML装配bean

• 需要在配置文件的顶部声明多个XML模式(XSD)文件，这些文件定义了配置Spring的XML元素
• 创建和管理Spring XML配置文件一种简便方式：https://spring.io/tools/sts STS>File>New>Spring Bean Configuration File
• 声明bean的方式：使用<bean>元素指定class属性
• 借助构造器注入初始化bean：<constructor-arg>元素和使用Spring3.0所引入的c-命名空间
• c:cd-ref="compactDisc"： c(命名空间前缀) cd(构造器参数名) ref(注入bean引用) compactDisc(要注入的bean的ID)
• 强依赖使用构造器注入，可选依赖使用属性注入

导入和混合配置

• 自动化和显示配置不是互斥的
• @Import注解可以导入JavaConfig到另一个JavaConifg中，或者在更高级类中把多个JavaConfig组合在一起
• @ImposrtResource注解，可以装配xml到JavaConfig中
• <import>XML导入另一个XML
• bean可以在XML中导入JavaConfig
• 组件扫描 <context:component-scan>或@Componenet
• 装配bean：自动化配置、基于Java的显示配置以及基于XML的显示配置

引用：《Spring In Action 4》第2章

spring 使用@Bean装配Bean

　　通过@Component装配Bean，但是@Component只能注解在类上，不能注解到方法上。对于Java而言，大部分的开发都需要引入第三方的包（jar文件），而且往往并没有这些包的源码，这时候将无法为这些包的类加入@Component注解，让它们变为开发环境的Bean。你可以使用新类扩展（extends）其包内的类，然后在新类上使用@Component，但是这样又显得不伦不类。这个时候Spring给予一个注解@Bean，它可以注解到方法之上，并且将方法返回的对象作为Spring的Bean，存放在IoC容器中。比如我们需要使用DBCP数据源，这个时候要引入关于它的包，然后可以通过代码清单来装配数据源的Bean。
　　代码清单：通过注解@Bean装配数据源Bean

import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.Properties;

@Component
public class AnnotationBean {

    @Bean(name = "dataSource2")
    public DataSource getDataSource() {
        Properties props = new Properties();
        props.setProperty("driver", "com.mysql.cj.jdbc.Driver");
        props.setProperty("url", "jdbc:mysql://localhost:3306/springmvc?useSSL=false&serverTimezone=Hongkong&characterEncoding=utf-8&autoReconnect=true");
        props.setProperty("username", "root");
        props.setProperty("password", "123456");
        DataSource dataSource = null;
        try {
            dataSource = (DataSource) BasicDataSourceFactory.createDataSource(props);
            System.out.println("getDataSource init");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dataSource;
    }

}

　　这样就能够装配一个Bean，当Spring IoC容器扫描它的时候，就会为其生成对应的Bean。这里还配置了@Bean的name选项为dataSource2，这就意味着Spring生成该Bean的时候就会使用dataSource2作为其BeanName。和其他Bean一样，它也可以通过@Autowired或者@Qualifier等注解注入别的Bean中。

import com.ssm.chapter10.annotation.pojo.Role;
import com.ssm.chapter10.annotation.service.RoleDataSourceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@Component
public class RoleDataSourceServiceImpl implements RoleDataSourceService {

    @Autowired
    @Qualifier("dataSource2")
    DataSource dataSource = null;

    // @Override
    public Role getRole(Long id) {
        Connection conn = null;
        ResultSet rs = null;
        PreparedStatement ps = null;
        Role role = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement("select id, role_name, note from t_role where id = ?");
            ps.setLong(1, id);
            rs = ps.executeQuery();
            while (rs.next()) {
                role = new Role();
                role.setId(rs.getLong("id"));
                role.setRoleName(rs.getString("role_name"));
                role.setNote(rs.getString("note"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            /**********close database resources************/
            try {
                rs.close();
                ps.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return role;
    }
}

　　spring-dataSource.xml:

<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">

    <context:component-scan base-package="com.ssm.chapter10.annotation"/>

</beans>

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("ssm/chapter10/spring-dataSource.xml");
RoleDataSourceServiceImpl roleDataSourceServiceImpl = context.getBean(RoleDataSourceServiceImpl.class);
Role role = roleDataSourceServiceImpl.getRole(1L);
System.out.println(role.toString());
context.close();

spring 学习总结 —— 装配 Bean 学习一（自动装配）

一、Spring 配置的可选方案

Spring 容器负责创建应用程序中的 bean 并通过 DI 来协调这些对象之间的关系。但是，作为开发人员，你需要告诉 Spring 要创建哪些 bean 并且如何将其装配在一起。当描述 bean 如何进行装配时，Spring 具有非常大的灵活性，它提供了三种主要的装配机制：

• 在 XML 中进行显式配置。
• 在 Java 中进行显式配置。（在 JavaConfig 中配置 @bean, 用于将第三方库装配到 spring 中）
• 隐式的 bean 发现机制和自动装配。（@Component 等注解；推荐使用）

二、自动装配

优点：在便利性方面相对于 XML、javaConfig 方式，最强大的还是 Spring 的自动化配置。如果 Spring 能够进行自动化装配的话，那何苦还要显式地将这些 bean 装配在一起呢？

Spring 从两个角度来实现自动化装配：

• 组件扫描（component scanning）：Spring 会自动发现应用上下文中所创建的 bean。
• 自动装配（autowiring）：Spring 自动满足 bean 之间的依赖。

组件扫描和自动装配组合在一起就能发挥出强大的威力，它们能够将你的显式配置降低到最少。

1. 例子说明：

定义一个 CD (CompactDisc) 接口，以及实现类 SgtPeppers，如下所示：

CompactDisc 接口

SgtPeppers 实现类

　　和 CompactDisc 接口一样，SgtPeppers 的具体内容并不重要。你需要注意的就是 SgtPeppers 类上使用了 @Component 注解。这个简单的注解表明该类会作为组件类，并告知 Spring 要为这个类创建 bean。没有必要显式配置 SgtPeppersbean，因为这个类使用了 @Component 注解，所以 Spring 会为你把事情处理妥当。

　　不过，组件扫描默认是不启用的。我们还需要显式配置一下 Spring，从而命令它去寻找带有 @Component 注解的类，并为其创建 bean。这时需要使用 @ComponentScan 注解启用了组件扫描；

JAVA 配置类 (JavaConfig) 展现了完成这项任务的最简洁配置。

如果没有其他配置的话，@ComponentScan 默认会扫描与配置类相同的包。因为 CDPlayerConfig 类位于 soundsystem 包中，因此 Spring 将会扫描这个包以及这个包下的所有子包，查找带有 @Component 注解的类。这样的话，就能发现 CompactDisc，并且会在 Spring 中自动为其创建一个 bean。

 通过 XML 启用组件扫描

2.@Component 和 @ComponentScan 的深入

2.1 @Component 命名

　　Spring 应用上下文中所有的 bean 都会给定一个 ID，默认将类名的第一个字母变为小写；如果想要自定义名称写法如下：

补充：Spring 支持将 @Named 作为 @Component 注解的替代方案。两者之间有一些细微的差异，但是在大多数场景中，它们是可以互相替换的。

 2.2 使用 @ComponentScan 设置扫描包

按照默认规则，它会以配置类所在的包作为基础包（basepackage）来扫描组件。如果你想扫描不同的包，那该怎么办呢？或者，如果你想扫描多个基础包，那又该怎么办呢？

1. @ComponentScan 的 value 属性中指明包的名称：

2. 如果你想更加清晰地表明你所设置的是基础包，那么你可以通过 basePackages 属性进行配置（basePackages 值为复数形式）

复数形式指定扫描多个包：

3. 指定为包中所包含的类或接口

可以看到，basePackages 属性被替换成了 basePackageClasses。同时，我们不是再使用 String 类型的名称来指定包，为 basePackageClasses 属性所设置的数组中包含了类。这些类所在的包将会作为组件扫描的基础包。

3. 通过为 bean 添加注解实现自动装配

简单来说，自动装配就是让 Spring 自动满足 bean 依赖的一种方法，在满足依赖的过程中，会在 Spring 应用上下文中寻找匹配某个 bean 需求的其他 bean。为了声明要进行自动装配，我们可以借助 Spring 的 @Autowired 注解；装配方式（构造方法、类的方法）

构造方法

类方法：

如果没有匹配的 bean，那么在应用上下文创建的时候，Spring 会抛出一个异常。为了避免异常的出现，你可以将 @Autowired 的 required 属性设置为 false：

Spring 实战 通过XML装配Bean

Spring从诞生之时就是使用XML来配置各个Bean。但是现在XML不再是配置的唯一选择，JavaConfig和AutoWired都是现在更加推荐的选择。这一章节主要是希望能够帮助我们维护现有的代码！！新写的代码还是比较推荐使用JavaConfig或者自动装配。

 2.4.1 创建XML配置规范 

以下就是一个标准的配置文件！<beans>标签内部可以声明所需要的Bean。用来装配Beans的最基本的XML元素包含在spring-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="compactdisc"https://www.jb51.cc/tag/stem/" target="_blank">stem.SgtPeppers"/>
</beans>

2.4.2 声明一个简单的<bean>

上面的那个配置中有声明一个Bean的<bean>标签，这个和@Bean的效果是一样的！class属性中放着这个bean的全限定名！如果没有添加id属性，则它的名字将会是soundSystem.SgtPeppers#0

使用如下的测试用例来测试！需要使用@ContextConfiguration注解来寻找classpath下的xml配置文件！

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:inner/springConfig.xml"})
public class CdplayerTest {

    @Autowired
    private Compactdisc cd;

    @Test
    public void cdShouldNotBeNull(){
        assertNotNull(cd);
    }
}

自动化的命名很方便，但是如果这个Bean需要被注入到另外一个Bean当中，则我们需要使用id属性来为它命名！只对那些需要注入到其他Bean中的Bean命名！

我们不再负责创建SgtPeppers的实例，Spring发现这个<bean>元素的时候，它将会调用默认的构造器来创建Bean!

和JavaConfig相比的缺点：

1. 使用xml比较被动，也没有Javaconfig来得强大，在Javaconfig中我们可以使用任何可以想象得到的方法来创建Bean。

2. Spring的XML配置不能从编译期的类型检查中获益，没人能够保证class属性中的内容是正确的，如果你重构了这个类或者重命名了这个类名，就会引起一些问题。

2.4.3 借助构造器注入初始化Bean

在Spring XML配置中，使用<bean>元素并指定class属性。Spring会从这里获取必要的信息来创建Bean。

构造器注入有两种配置方式可以选择：

1. <constructor-arg>元素：繁琐但是能力强

2. c-命名空间：简单但是有些事情做不到

constructor 的方式如下，将compactdisc注入到了Cdplayer当中

<?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">

    <bean id="compactdisc"https://www.jb51.cc/tag/stem/" target="_blank">stem.SgtPeppers"/>
    <bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer">
        <constructor-arg ref="compactdisc"/>
    </bean>
</beans>

c-命名空间：需要添加c标签的引用，使用cd-ref来注入compactdisc。

<?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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="compactdisc"https://www.jb51.cc/tag/stem/" target="_blank">stem.SgtPeppers"/>
    <bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer" c:cd-ref="compactdisc"/>
</beans>

c:cd-ref="compactdisc" 是怎么组成的

"c:"开头，命名空间前缀

"cd": 构造器的参数名字

”-ref"，的意思是告诉spring，正在装配的是一个bean的引用compactdisc，而不是“compactdisc"这个字面量。（String）

这里直接使用了构造器参数的名称，引用参数名称有点怪异 如果改了名字就会报错？调试标志？是什么意思？

其他的引用方法：

只有一个构造器参数的时候使用
<bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer" c:_-ref="compactdisc"/>
参数索引，使用0代表第一个参数，因为标签不能以数字开头所有用一个下划线_开头
<bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer" c:_0-ref="compactdisc"/>

字面量

<?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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="compactdisc"https://www.jb51.cc/tag/stem/" target="_blank">stem.Blankdisc">
        <constructor-arg value="Sgt. Pepper's Lonely Hearts Club Banc"/>
        <constructor-arg value="The Beatles"/>
    </bean>
    <bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer" c:input-ref="compactdisc"/>
</beans>

我们之前的例子，compactdisc里面的东西是写死在类里面的，但是我们也可以使用字面量注入来更加灵活地配置类！！ref标签变成了value，就代表注入了字面量。

同样的我们也可以使用c标签！好像和书上有出入，书上有_, _artist, _title

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

    <bean id="compactdisc"https://www.jb51.cc/tag/stem/" target="_blank">stem.Blankdisc"
          c:artist="The Beatles"
          c:title="Sgt. Pepper's Lonely Hearts Club Banc"/>
    <bean id="cdplayer"https://www.jb51.cc/tag/stem/" target="_blank">stem.Cdplayer" c:input-ref="compactdisc"/>
</beans>

目前来看，在装配bean引用和字面量值方面，构造器注入和c命名空间是相同的，但是却无法装配集合。

关于spring学习总结——装配Bean学习三和xml装配bean的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于Spring - 装配Bean、spring 使用@Bean装配Bean、spring 学习总结 —— 装配 Bean 学习一（自动装配）、Spring 实战 通过XML装配Bean的相关知识，请在本站寻找。