Spring实现了纯注解配置的自动化隐式装配,betw

慢慢来比较快,虚心学技术

前言:创建应用对象之间协作关系的行为通常称为装配,这也是依赖注入的本质

Spring提供三种Bean装配机制:

  1. 在 XML 中进行显式配置。
  2. 在 Java 中进行显式配置
  3. 隐式的 bean 发现机制和自动装配

1 Spring组件扫描:

1,XML配置文件启用组件扫描,通过注解配置扫描base-package包下的所有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"
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="org.example"/>
</beans>

2,通过Java class
通过类进行启用扫描

//只不过它使用了@ComponentScan注解,这个注解能够在Spring中启用组件扫描

//如果没有其他配置的话,@ComponentScan默认会扫描与配置类相同的包
@Configuration
@ComponentScan(basePackages = "com.kason.soundsystem")
public class CDPlayerConfig {

}

默认情况下@ComponentScan是不需要填参数的,那么它的意思是扫描你写的这个Config类所在的包下的所有组件。同时呢可以使用basePackages指定要扫描的包。还有一种就是指定具体的类,比如:、

package com.kason.config;

import com.kason.soundsystem.CompactDisc;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * Created by IBM on 2017/5/29.
 */
//只不过它使用了@ComponentScan注解,这个注解能够在Spring中启用组件扫描

//如果没有其他配置的话,@ComponentScan默认会扫描与配置类相同的包
@Configuration
@ComponentScan(basePackageClasses = {CompactDisc.class})
public class CDPlayerConfig {

}

如果需要指定多个包或者多个class可以使用{}将其括起来。

  使用建议:尽可能使用自动配置的机制,显示配置越少越好,若必须要显式配置bean的时候,(例如有些源码并非自己维护,需要为这些代码配置bean的时候),推荐使用类型安全并且比XML更加强大的JavaConfig,

但是,尽可能的用自动装配,显式装配越少越好.当不得不显式装配的时候(比如,有些源码不是你来维护的,但你要为这些代码配置bean的时候),推荐使用JavaConfig,因为他XML更安全更强大.只有在你想用XML的命名空间,并且在JavaConfig中没有同样的实现,才选择XML.

2.3.2 定义bean

通过@Bean注解创建一个Spring bean,该bean的默认ID和函数的方法名相同,即sgtPeppers。例如:

@Beanpublic CompactDisc sgtPeppers() { return new SgtPeppers();}

同样,可以指定bean的ID,例如:

@Bean(name = "lonelyHeartsClub")public CompactDisc sgtPeppers() { return new SgtPeppers();}

可以利用Java语言的表达能力,实现类似工厂模式的代码如下:

@Beanpublic CompactDisc randomBeatlesCD() { int choice = Math.floor(Math.random; if (choice == 0) { return new SgtPeppers(); } else if (choice == 1) { return new WhiteAlbum(); } else if (choice == 2) { return new HardDaysNight(); } else if (choice == 3) { return new Revolover(); }}

ⅲ.关注点:

① 提供另一种测试方式:通过上一篇文章中提及的AnnotationConfigApplicationContext上下文实现进行测试

public static void main(String[] args) { /** * 注解配置实现,同时指定配置类的位置,否则无法读取配置进行扫描,默认只有Spring自带的组件 */ ApplicationContext applicationContext = new AnnotationConfigApplicationContext(CDConfig.class); /** *获取应用上下文中的所有Bean名称 */ String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames(); for (String className : beanDefinitionNames){ System.out.println(className); } /** *从上下文中获取对应的Bean */ CDPlayer cdPlayer = applicationContext.getBean(CDPlayer.class); /** *调用具体方法测试是否成功 */ cdPlayer.playCD();}

测试结果:自动装配成功,依赖注入成功

org.springframework.context.annotation.internalConfigurationAnnotationProcessororg.springframework.context.annotation.internalAutowiredAnnotationProcessororg.springframework.context.annotation.internalCommonAnnotationProcessororg.springframework.context.event.internalEventListenerProcessororg.springframework.context.event.internalEventListenerFactoryCDConfigapp//当前测试类的名字CDBeanCDPlayerImpl正在播放:The World! by Mr.D

为装配的Bean命名

Spring 应用上下文中所有的 bean 都会给定一个 ID,默认是类名的首字母小写命名,我们可以为装配的Bean装配一个不一样的ID,在 @Component注解中有一个属性value,该值可指定bean在Spring容器中的ID,其在@Component注解的源码定义如下:

public @interface Component { /** * The value may indicate a suggestion for a logical component name, * to be turned into a Spring bean in case of an autodetected component. * @return the suggested component name, if any (or empty String otherwise) */ String value() default "";}

我们可以给CDPlayerImpl指定一个别的ID:cdPlayer

@Component(value = "cdPlayer")public class CDPlayerImpl implements CDPlayer { @Autowired private CDBean cdBean; @Override public void playCD() { System.out.println("正在播放:"+cdBean.getTitle()+" by "+cdBean.getAuthor; }}

此时执行上一测试代码结果中,CDPlayerImpl在容器中的ID类名将变成cdPlayer

另:可以使用@Name代替@Component注解为Bean命名,但是为了避免概念模糊,建议使用@Component注解

设置组件扫描的基础包

上述代码中,配置类CDConfig仅能扫描自身所在包及其子包的组件,能否指定扫描某个或多个包及其子包中的组件呢?

我们看到@ComponentScan注解的源码中定义的几个属性:

public @interface ComponentScan { /** * Alias for {@link #basePackages}. * <p>Allows for more concise annotation declarations if no other attributes * are needed &mdash; for example, {@code @ComponentScan("org.my.pkg")} * instead of {@code @ComponentScan(basePackages = "org.my.pkg")}. */ @AliasFor("basePackages") String[] value() default {}; /** * Base packages to scan for annotated components. * <p>{@link #value} is an alias for (and mutually exclusive with) this * attribute. * <p>Use {@link #basePackageClasses} for a type-safe alternative to * String-based package names. */ @AliasFor String[] basePackages() default {}; /** * Type-safe alternative to {@link #basePackages} for specifying the packages * to scan for annotated components. The package of each class specified will be scanned. * <p>Consider creating a special no-op marker class or interface in each package * that serves no purpose other than being referenced by this attribute. */ Class<?>[] basePackageClasses() default {};} 

从源码得知,我们可以通过配置basePackages和basePackageClasses属性来指定配置扫描的范围,其中:

basePackages指定组件扫描的包路径(使用{}包含的数组)

@ComponentScan(basePackages = {"com.my.spring","com.my.test"})//指定扫描com.my.spring包和com.my.test包及其子包下的组件@Configurationpublic class CDConfig {}

basePackageClasses:指定以该类数组所在包及其子包为组件扫描范围

@ComponentScan(basePackageClasses = {App.class})//指定扫描App.class所在包及其子包下的组件@Configurationpublic class CDConfig {}

注:通常,为了防止因包路径更改以及业务实体类更改等因耦合而产生的问题,我们通常会使用一个不具备任何业务意义的空接口作为扫描包的类

自动注入注解@Autowired的使用

可以用在属性,构造函数,setter以及任何一个普通方法中

@Component(value = "cdPlayer")public class CDPlayerImpl implements CDPlayer { //1.在属性注入 @Autowired private CDBean cdBean; public CDPlayerImpl}; //2.在构造函数中注入 @Autowired public CDPlayerImpl(CDBean cdBean){super()}; //3.在setter方法中注入 @Autowired public void setCDBean(CDBean cdBean){this.cdBean = cdBean}; //4.在普通方法中使用 @Autowired @Override public void playCD(CDBean cdBean) { System.out.println("正在播放:"+cdBean.getTitle()+" by "+cdBean.getAuthor; }}

1.自动化装配使用全注解方式替代XML和JavaConfig显式装配方式,方便简洁

2.自动化装配依赖于几个特殊注解:@Autowired,@Component,@ComponentScan和@Configuration

3.@Component注解可以将类定义为装配的组件,同时可以为改组件另起别名

4.@Configuration将使用该注解的当前类标注为配置类,@ComponentScan开启自动扫描,默认扫描当前配置类所在的包及其子包中含有或使用了@Component注解的类,可通过属性指定扫描范围

5.@Autowired注解可以用在属性,构造函数,setter以及任何一个普通方法中,是Spring依赖注入的核心注解

《Spring 实战》·Craig Walls

2.2 通过Java代码装配Bean

尽管在很多场景下通过组件扫描和自动装配实现Spring的自动化配置是更为推荐的方式,但
有时候自动化配置的方案行不通,因此需要明确配置Spring。比如说,你想要将第三方库中的
组件装配到你的应用中,在这种情况下,是没有办法在它的类上添加@Component和
@Autowired注解的,因此就不能使用自动化装配的方案了。在这种情况下,你必须要采用显式装配的方式。

在进行显式配置的时候,有两种可选方案:
Java和XML

  4.2 声明一个简单的<bean>

  声明CompactDisc bean:

<bean class="soundsystem.SgtPeppers"/>

  4.3 借助构造器注入初始化bean

<bean id ="cdPlayer" class ="soundsystem.CDPlayer">    <constructor-arg ref = "compactDisc"/></bean>

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

  

在Spring中,容器负责对象的创建并通过DI来协调对象之间的关系.但是我们要告诉Spring创建哪些Bean并且如何将其装配在一起.,装配wiring就是DI依赖注入的本质. 

  • 基于XML文件的显式装配
  • 基于Java文件的显式装配
  • 隐式bean发现机制和自动装配

ⅱ.基本实现:

①定义基本接口CDPlayer

public interface CDPlayer { /** * 定义方法播放CD * @param * * @return void * * @author lai.guanfu 2019/2/27 * @version 1.0 **/ void playCD();}

②定义基本类CDBean

@Data//Data是lobok的注解,自动添加setter和getter方法等@Component//将当前类定义为可扫描的组件public class CDBean { /** * 定义CD名 */ private String title="The World!"; /** * 定义CD作者 */ private String author="Mr.D";}

③定义实现类CDPlayerImpl,并将CDBean作为属性注入

@Component//将当前类定义为可扫描的组件public class CDPlayerImpl implements CDPlayer { /** * 从Spring容器注入CDBean-----依赖注入 */ @Autowired private CDBean cdBean; @Override public void playCD() { System.out.println("正在播放:"+cdBean.getTitle()+" by "+cdBean.getAuthor; }}

④定义配置类CDConfig,并开启注解扫描

@ComponentScan()//开启注解扫描@Configuration//指定当前类为配置类public class CDConfig {}

⑤编写测试

此处使用Spring提供的测试类SpringJUnit4ClassRunner帮助测试,以便在测试开始的时候自动创建 Spring 的应用上下文

而@ContextConfiguration可以指定创建上下文的加载方式以及配置的位置等

@RunWith(SpringJUnit4ClassRunner.class)//辅助创建Spring应用上下文@ContextConfiguration(loader = AnnotationConfigContextLoader.class,classes = {CDConfig.class})//指定创建上下文的加载方式以及配置的位置public class AppTest { /** * 从Spring容器注入CdPlayer-----依赖注入 */ @Autowired private CDPlayer cdPlayer; /** * Rigorous Test :-) */ @Test public void play() { //调用playCD方法测试是否自动装配及依赖注入成功 this.cdPlayer.playCD(); }}

⑥测试结果,自动装配成功,依赖注入成功

正在播放:The World! by Mr.D

2 装配Bean

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

@Autowiredpublic CDPlayer(CompactDisc cd){    this.cd = cd  }

   即通过@Autowired注解在构造器之上,当然@Autowired注解不仅能够用在构造器之上,还能用在属性的Setter方法。

明天会学习通过Java代码装配bean,xml配置装配bean.

创建各个对象之间协作关系的行为通常被称为装配,这就是依赖注入的本质。

很显然,通过前两篇文章的描述,我们可以发现,Spring的配置方式可以很简洁,也可以也很复杂,JavaConfig配置方式使用大量的注解替代了XML中的配置,那么,基于JavaConfig的基础之上,是否可以再次封装或简化配置呢?

2.2.1 JAVA显示装配Bean

在进行显式配置时,JavaConfig是更好的方案,因为它更为强大、类型安全并且对重构友好。因为它就是Java代码,就像应用程序中的其他Java代码一样JavaConfig是配置代码。这意味着它不应该包含任何业务逻辑,JavaConfig也不应该侵入到业务逻辑代码之中。尽管不是必须的,但通常会将JavaConfig放到单独的包中,使它与其他的应用程序逻辑分离开来,这样对于它的意图就不会产生困惑了。
步骤:

  • 创建配置类
    @Configuration
    public class CDPlayerConfig {

}
创建JavaConfig类的关键在于为其添加@Configuration注解,@Configuration注解表明这个类是一个配置类,该类应该包含在Spring应用上下文中如何创建bean的细节。
到此为止,我们都是依赖组件扫描来发现Spring应该创建的bean。尽管我们可以同时使用组件扫描和显式配置,但是在本节中,我们更加关注于显式配置,因此我将CDPlayerConfig的@ComponentScan注解移除掉了。

  • 声明简单的Bean
    要在JavaConfig中声明bean,我们需要编写一个方法,这个方法会创建所需类型的实例,然后给这个方法添加@Bean注解
@Bean
    public CompactDisc sgtPeppers(){
        return new SgtPeppers();
    }

@Bean注解会告诉Spring这个方法将会返回一个对象,该对象是一个要注册为Spring应用上下文中的bean。
默认情况下,bean的ID与带有@Bean注解的方法名是一样的。在本例中,bean的名字将会是sgtPeppers。如果你想为其设置成一个不同的名字的话,那么可以重命名该方法,也可以通过name属性指定一个不同的名字:

 @Bean(name = "sgtPeppers_another")
    public CompactDisc sgtPeppers(){
        return new SgtPeppers();
    }

关于装配Bean的建议:
建议尽可能使用自动化配置,以避免显式配置所带来的维护成本。但是,如果你确实需要显式配置Spring的话,应该优先选择基于Java的配置,它比基于XML的配置更加强大、类型安全并且易于重构。

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

    组件扫描(component scanning):Spring会自动发现应用的上下文中所创建的bean。

    自动装配(autowiring):Spring自动满足bean之间的依赖。

  CompactDisc接口在Java中定义CD的概念

1 package soundsystem;2 3 public interface CompactDisc{4       void play();  5 }

  

  带有@Component注解的CompactDisc实现类SgtPeppers

 1 package soundsystem; 2  3 import org.springframework.stereotype.Component; 4  5 @Component 6 public class SgtPeppers implements CompactDisc { 7     private String title = "Sgt.Pepper's Lonely Hearts Club Band"; 8     private String artist = "The Beatles"; 9 10     public void play() {11         System.out.println("Playing " + title + " by " + artist);12     }13 }

  此处实现类功能暂时不重要,重要的是 @Component注解的作用:表明该类会作为组件类,并告知Spring需要为这个类创建bean,故而不需要显式配置SgtPeppers bean。

  

  @ComponentScan注解启用了组件扫描

1 package soundsystem;2 3 import org.springframework.context.annotation.ComponentScan;4 import org.springframework.context.annotation.Configuration;5 6 @Configuration7 @ComponentScan8 public class CDPlayerConfig {9 }

  组件扫描默认是不启用的,需要显式的配置Spring,此处通过Java代码定义了Spring的装配规则,在Spring中启用组件扫描。

  在没有其他配置下,@ComponentScan只会默认扫描与配置类相同的包。

当然,也可以用XML文件来启用组件扫描,即可以使用Spring context命名空间的<context:component-scan>元素。

  通过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"       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="soundsystem"/></beans>

五,通过bean添加注解实现自动装配
上面我们学会了怎么将类设置为扫描类,让容器对对象的生老病死负责,但是他们仍然一个个是独立的,怎么让对象之间的相互依赖达成呢?  这就要用到自动注入:将组建扫描得到的Bean和他们的依赖装配在一起.

2.3.1 创建配置类

实际上在之前的例子中我们已经实践过基于Java的配置文件,看如下代码:

@Configuration@ComponentScan(basePackageClasses = {CDPlayer.class, DVDPlayer.class})public class SoundSystemConfig {}

@Configuration注解表示这个类是配置类,之前我们是通过@ComponentScan注解实现bean的自动扫描和创建,这里我们重点是学习如何显式创建bean,因此首先将@ComponentScan(basePackageClasses = {CDPlayer.class, DVDPlayer.class})这行代码去掉。

其中包含两个概念:

2.1 给Bean添加注解实现自动装配

前面我们看到了我们配置了让Spring去实现扫描,现在则需要实现装配,这样才能实现DI
简单来说,自动装配就是让Spring自动满足bean依赖的一种方法,在满足依赖的过程中,会在
Spring应用上下文中寻找匹配某个bean需求的其他bean。这里我们可以使用@Autowired注解

使用@Autowired会有一个问题,那就是当有多个bean都满足依赖关系的话,Spring将会抛出一个异常,表明没有明确指定要选择哪个bean进行自动装配

四、通过XML装配bean

@Component("gouzi")
public class Dog implements Animal{
   ...
}


//huozhe  yong @Named 

@Named("gouzi")
public class Dog implements Animal{
   ...
}

任何一个成功的应用都是由多个为了实现某个业务目标而相互协作的组件构成的,这些组件必须相互了解、能够相互协作完成工作。例如,在一个在线购物系统中,订单管理组件需要与产品管理组件以及信用卡认证组件协作;这些组件还需要跟数据库组件协作从而进行数据库读写操作。

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

  3.1 创建配置类

*  修改CDPlayerConfig的配置:*

package soundsystem; import org.springframework.context.annotation.Configuration; @Configurationpublic class CDPlayerConfig {}

在自动装配的过程中,会在spring应用上下文中寻找匹配某个bean需求的其他Bean.然后用@Autowired声明.

  • Spring的配置方法概览
  • 自动装配bean
  • 基于Java配置文件装配bean
  • 控制bean的创建和销毁

Spring实现了纯注解配置的自动化隐式装配,所谓的隐式装配就是不需要像XML和JavaConfig一样去为每一个Bean创建<bean>节点或再配置类中为每个Bean做注解,而是通过一些特殊的注解实现控制

  3.2 声明简单的bean

  在JavaConfig中申明bean,需要编写一个方法,这个方法会创建所需类型的实例,然后给这个方法添加@Bean注解,如下方代码:

@Beanpublic CompactDisc sgtPeppers(){    return new SgtPeppers();  }

  @Bean 注解会告诉Spring这个方法将会返回一个对象,该对象要注册为Spring应用上下文中的bean。

  默认情况下,bean的ID与带有@Bean注解的方法名是一样的。

  也可以通过name属性指定一个不同的名字:

@Bean(name="lonelyHeartsClubBand")public CompactDisc sgtPeppers(){   return new SgtPeppers();  }

1.先创建一个动物接口,定义了有个play方法 用面向接口的方法能松耦.接口的内容并不重要

2.5.1 在JavaConfig中解析XML配置

  • 通过@Import注解导入其他的JavaConfig,并且支持同时导入多个配置文件;
@Configuration@Import({CDPlayerConfig.class, CDConfig.class})public class SoundSystemConfig {}
  • 通过@ImportResource注解导入XML配置文件;
@Configuration@Import(CDPlayerConfig.class)@ImportResource("classpath: cd-config.xml")public class SoundSystemConfig {}

2.5.2 在XML配置文件中应用JavaConfig

  • 通过<import>标签引入其他的XML配置文件;
  • 通过<bean>标签导入Java配置文件到XML配置文件,例如
<bean />

通常的做法是:无论使用JavaConfig或者XML装配,都要创建一个root configuration,即模块化配置定义;并且在这个配置文件中开启自动扫描机制:<context:component-scan>或者@ComponentScan

这一章中学习了Spring 装配bean的三种方式:自动装配、基于Java文件装配和基于XML文件装配。

由于自动装配几乎不需要手动定义bean,建议优先选择自动装配;如何必须使用显式配置,则优先选择基于Java文件装配这种方式,因为相比于XML文件,Java文件具备更多的能力、类型安全等特点;但是也有一种情况必须使用XML配置文件,即你需要使用某个名字空间(name space),该名字空间只在XML文件中可以使用。

ⅰ.四个基本注解

@Autowired :标记于属性,方法等,自动装配的关键注解,依赖注入的表现,该注解可以自动寻找并从Spring容器中提取使用该注解的bean并注入到对应的属性中去

@Component :标记于类,标明当前类是一个可被扫描的组件

@ComponentScan :标记于配置类,开启组件注解扫描

@Configuration :标记于配置类,标明当前类是一个配置类

  4.1 创建XML配置规范

  在XML配置中,意味着要创建一个XML文件,并且要以<beans>元素为根。

  最简单的Spring 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">     <!--configuration details go here--></beans>

三 为组件扫描的bean命名
Spring应用上下文中所有的bean都会有一个ID.如果没有明确那么ID则是类名首字母小写.当然我们也可以认为的设置一个自己中意的ID,我们要做的就是讲ID作为值传递给@Component注解,比如我想为Dog类创建ID为gouzi :

  • Component scanning——Spring自动扫描和创建应用上下文中的beans;
  • Autowiring——Spring自动建立bean之间的依赖关系;

五、导入和混合配置

  5.1 在JavaConfig中引用XML配置

  1、如果需要将两个类组合在一起,使用方式就是使用@Import注解导入另一个类,如在CDPlayerConfig类中导入CDConfig:

package soundsystem;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Import;@Configuration@Import(CDConfig.class)public class CDPlayerConfig {    @Bean    public CDPlayer cdPlayer(CompactDisc compactDisc) {        return new CDPlayer(compactDisc));    }}

  2、或者采用一个更好的办法,也就是不在CDPlayerConfig中使用@Import,而采用一个更高级别的SoundSystemConfig,在这个类中使用@Import将两个配置类组合在一起:

package soundsystem;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Import;@Configuration@Import({CDConfig.class,CDPlayerConfig.class})public class SoundSystemConfig{}

  3、让Spring同时加载XML配置文件以及其他基于Java的配置:

package soundsystem;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Import;import org.springframework.context.annotation.ImportResource;@Configuration@Import(CDPlayerConfig.class)@ImportResource("classpath:cd-config.xml")public class SoundSystemConfig{}

  5.2 在XML配置中引用JavaConfig

   将BlankDisc bean 拆分到自己的配置文件中,该文件名为cd-config.xml,在XML配置文件中使用<import> 元素来引用该文件:

 <?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">    <import resource="cd-config.xml"/>    <bean id="cdPlayer"          class="soundsystem.CDPlayer"          c:cd-ref = "compactDisc"/></beans>

   为了将JavaConfig类导入到XML配置中,可以这样声明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" 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 class="soundsystem.CDConfig"/>    <bean id="cdPlayer"          class="soundsystem.CDPlayer"          c:cd-ref = "compactDisc"/></beans>

参考文档:《Spring实战第4版》

注:本篇学习文章的实例代码以及内容大多数来源于参考文档,仅供本人参考学习,加深理解之用,无任何商业用途,转载请与本人联系,若私自转载用于商业用途,一切后果自负。

  

Spring装配bean有几种机制:

在Spring应用中,对象无需自己负责查找或者创建与其关联的其他对象,由容器负责将创建各个对象,并创建各个对象之间的依赖关系。例如,一个订单管理组件需要使用信用卡认证组件,它不需要自己创建信用卡认证组件,只需要定义它需要使用信用卡认证组件即可,容器会创建信用卡认证组件然后将该组件的引用注入给订单管理组件。

本文由必威发布于必威-编程,转载请注明出处:Spring实现了纯注解配置的自动化隐式装配,betw

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。