spring---xml属性 1

spring配置文件属性说明

一、bean的内置属性

1、id属性

​ id为bean的唯一标识名，就是常说的beanName。它必须是合法的XMLID，在整个XML文档中唯一。name属性：用来为bean id创建一个或多个别名（这里是别名不是beanName），它可以是任意的字母符合，多个别名之间用逗号或空格分开。如果没有定义bean的id，那么第一个别名就会被作为id；如果也没有定义name，那么自动生成一个id和一个别名（这时的别名为类的全类名且类名首子母小写）。

2、class属性：

​ 用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。

3、parent属性

​ 子类Bean定义它所引用它的父类Bean。这时class属性失效。子类Bean会继承父类Bean的所有属性，子类Bean也可以覆盖父类Bean的属性。注意：子类Bean和父类Bean是同一个Java类。

4、abstract属性

​ 默认为”false”，用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化，一般用于父类Bean，因为父类Bean主要是供子类Bean继承使用。

5、scope 属性

​ 默认为singleton（单例）。如果设prototype（原型）状态，BeanFactory将为每次Bean请求创建一个新的Bean实例。

6、lazy-init属性

​ 用来定义这个Bean是否实现懒初始化。默认为“default” ，如果为“true”，它将在BeanFactory启动时初始化所有的SingletonBean。反之，如果为“false”,它只在Bean请求时才开始创建SingletonBean。

7、autowire属性

​ 它定义了Bean的自动装载方式。
​ 1、“no”:不使用自动装配功能。
​ 2、“byName”:通过Bean的属性名实现自动装配。
​ 3、“byType”:通过Bean的类型实现自动装配。
​ 4、“constructor”:类似于byType，但它是用于构造函数的参数的自动组装。
​ 5、“default”：默认值，自动装配。

8、depends-on属性

@DependsOn
1：直接或者间接标注在带有@Component注解的类上面;
2：直接或者间接标注在带有@Bean 注解的方法上面;

​ 这个Bean在初始化时依赖的对象，这个对象会在这个Bean初始化之前创建。

9、init-method属性

​ 用来定义Bean的初始化方法，它会在Bean组装之后调用。它必须是一个无参数的方法。

10、destroy-method属性

​ 用来定义Bean的销毁方法，它在BeanFactory关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singletonBean。

11、factory-method属性

​ 定义创建该Bean对象的工厂方法。它用于下面的“factory-bean”，表示这个Bean是通过工厂方法创建。此时，“class”属性失效。

12、factory-bean属性：

​ 定义创建该Bean对象的工厂类。如果使用了“factory-bean”则“class”属性失效。

二、bean的子元素

1、meta：元数据

​ 当需要使用里面的信息时可以通过key获取

a.元数据的应用场景

​ 一个公共工程中的Spring配置文件，可能会被多个工程引用。因为每个工程可能只需要公共工程中的一部分Bean，所以这些工程的Spring容器启动时，需要区分开哪些Bean要创建出来。(在各种工程实现中，Spring Bean激活哪些bean的方案)

b.解决

1）、xml样例

<bean name="xmlPageManager"class="org.apache.jetspeed.page.psml.CastorXmlPageManager"init-method="init" destroy-method="destroy">
    <meta key="j2:cat" value="xmlPageManager orpageSerializer" />
    <constructor-arg index="0">
      <ref bean="IdGenerator"/>
    </constructor-arg>
    <constructor-arg index="1">
      <refbean="xmlDocumentHandlerFactory" />
    </constructor-arg>
    ……
  </bean>
 
  <bean id="dbPageManager"class="org.apache.jetspeed.page.impl.DatabasePageManager"init-method="init" destroy-method="destroy">
    <meta key="j2:cat" value="dbPageManager orpageSerializer" />
    <!-- OJB configuration file resourcepath -->
    <constructor-arg index="0">
     <value>JETSPEED-INF/ojb/page-manager-repository.xml</value>
    </constructor-arg>
    <!-- fragment id generator -->
    <constructor-arg index="1">
      <ref bean="IdGenerator"/>
    </constructor-arg>
    ……
  </bean>

2）、bean过滤器：

​ JetspeedBeanDefinitionFilter在Spring容器解析每个Bean定义时，会取出上面Bean配置中j2:cat对应的值，例如dbPageManageror pageSerializer。然后将这部分作为正则表达式与当前的Key(从配置文件中读出)进行匹配。只有匹配上的Bean，才会被Spring容器创建出来。

 public boolean match(BeanDefinition bd) {
        String beanCategoriesExpression = (String)bd.getAttribute(CATEGORY_META_KEY);
        boolean matched = true;
        if (beanCategoriesExpression != null) {
            matched = ((matcher != null)&& matcher.match(beanCategoriesExpression));
        }
        return matched;
}
    public void registerDynamicAlias(BeanDefinitionRegistry registry, String beanName,BeanDefinition bd) {
        String aliases =(String)bd.getAttribute(ALIAS_META_KEY);
        if (aliases != null) {
            StringTokenizer st = newStringTokenizer(aliases, " ,");
            while (st.hasMoreTokens()) {
                String alias = st.nextToken();
                if (!alias.equals(beanName)) {
                    registry.registerAlias(beanName, alias);
                }
            }
        }
    }

​ match()方法中的CATEGORY_META_KEY的值就是j2:cat，matcher类中保存的就是当前的Key，并负责将当前Key与每个Bean的进行正则表达式匹配。
registerDynamicAlias的作用是：在Bean匹配成功后，定制的Spring容器会调用此方法为Bean注册别名。详见下面1.3中的源码。

3）、.定制Spring容器

定制一个Spring容器，重写registerBeanDefinition()方法，在Spring注册Bean时进行拦截。

public class FilteringXmlWebApplicationContextextends XmlWebApplicationContext {
    private JetspeedBeanDefinitionFilterfilter;
   
    publicFilteringXmlWebApplicationContext(JetspeedBeanDefinitionFilter filter, String[]configLocations, Properties initProperties, ServletContext servletContext) {
        this(filter, configLocations,initProperties, servletContext, null);
    }
   
    publicFilteringXmlWebApplicationContext(JetspeedBeanDefinitionFilter filter, String[]configLocations, Properties initProperties, ServletContext servletContext,ApplicationContext parent)  {
        super();
        if (parent != null) {
            this.setParent(parent);
        }
        if (initProperties != null) {
            PropertyPlaceholderConfigurer ppc =new PropertyPlaceholderConfigurer();
           ppc.setIgnoreUnresolvablePlaceholders(true);
           ppc.setSystemPropertiesMode(PropertyPlaceholderConfigurer.SYSTEM_PROPERTIES_MODE_FALLBACK);
            ppc.setProperties(initProperties);
            addBeanFactoryPostProcessor(ppc);
        }
        setConfigLocations(configLocations);
        setServletContext(servletContext);
        this.filter = filter;
    }
   
    protected DefaultListableBeanFactorycreateBeanFactory() {
        return new FilteringListableBeanFactory(filter,getInternalParentBeanFactory());
    }
}
 
public classFilteringListableBeanFactory extends DefaultListableBeanFactory {
    private JetspeedBeanDefinitionFilterfilter;
   
    public FilteringListableBeanFactory(JetspeedBeanDefinitionFilterfilter, BeanFactory parentBeanFactory) {
        super(parentBeanFactory);
        this.filter = filter;
        if (this.filter == null) {
            this.filter = newJetspeedBeanDefinitionFilter();
        }
        this.filter.init();
    }
 
    /**
     * Override of the registerBeanDefinitionmethod to optionally filter out a BeanDefinition and
     * if requested dynamically register anbean alias
     */
    public void registerBeanDefinition(StringbeanName, BeanDefinition bd)
            throws BeanDefinitionStoreException {
        if (filter.match(bd)) {
           super.registerBeanDefinition(beanName, bd);
            if (filter != null) {
                filter.registerDynamicAlias(this, beanName, bd);
            }
        }
    }
}

4）、最后

​ 使用BeanReferenceFactoryBean工厂Bean，将上面配置的两个Bean(xmlPageManager和dbPageManager)包装起来。将Key配成各自的，实现通过配置当前Key来切换两种实现。别名都配成一个，这样引用他们的Bean就直接引用这个别名就行了。例如下面的PageLayoutComponent。

<bean class="org.springframework.beans.factory.config.BeanReferenceFactoryBean">
    <meta key="j2:cat"value="xmlPageManager" />
    <meta key="j2:alias"value="org.apache.jetspeed.page.PageManager" />
    <propertyname="targetBeanName" value="xmlPageManager" />
  </bean>
 
  <bean class="org.springframework.beans.factory.config.BeanReferenceFactoryBean">
    <meta key="j2:cat"value="dbPageManager" />
    <meta key="j2:alias"value="org.apache.jetspeed.page.PageManager" />
    <propertyname="targetBeanName" value="dbPageManager" />
  </bean>
 
  <bean id="org.apache.jetspeed.layout.PageLayoutComponent"
    class="org.apache.jetspeed.layout.impl.PageLayoutComponentImpl">
    <meta key="j2:cat"value="default" />
    <constructor-arg index="0">
      <refbean="org.apache.jetspeed.page.PageManager" />
    </constructor-arg>
    <constructor-arg index="1">
      <value>jetspeed-layouts::VelocityOneColumn</value>
    </constructor-arg>
  </bean>

2、lookup-method

​ 获取器注入，是把一个方法声明为返回某种类型的 bean 但实际要返回的 bean 是在配置文件里面配置的。该方法可以用于设计一些可插拔的功能上，解除程序依赖。

a.场景说明

​ spring默认Bean 都是 singleton 的。如果singleton 依赖 singleton、prototype 依赖 prototype 直接设置属性依赖即可。可是如果在singleton的bean中依赖了prototype的bean，就会出现，单例bean中的原型bean每次获取的都是同一个对象。现在的目标是每次调用start方法，都会实例化一个新的prototypeBean，有如下几种方案：

1、原始样例

@Service(Scope="singleton")
public class SingletonServiceImpl implements SingletonService{
    @Resource
    PrototypeBean prototypeBean;//直接在单例模式中注入原型bean，prototypeBean其实只实例化了一次，原型模式的作用完全没有发挥
    public void start(){
        prototypeBean.setFoo(new Foo());
        prototypeBean.setBar(new Bar());
        process(prototypeBean);

    }
    public void process(PrototypeBean prototypeBean){
        //......
    }
}

@Service(Scope="prototype")
public class PrototypeBean{
    private int count = 0;
    private Foo foo;
    private Bar bar;
    public void setFoo(Foo foo){
        this.foo = foo;
        count = count+1;
        System.out.println(count);
    }
    public void setBar(Bar bar){
        this.bar = bar;
        count = count+1;
        System.out.println(count);
    }
}

2、解决

方案1：实现ApplicationContextAware接口

​ 每次获取依赖的原型 bean 从 BeanFactory 中取，即实现ApplicationContextAware接口。不推荐：原因在于但是如果用ApplicationContextAware接口，就让我们与Spring代码耦合了，违背了反转控制原则（IoC，即bean完全由Spring容器管理，我们自己的代码只需要用bean就可以了）。

java方式

@Service(Scope="singleton")
public class SingletonServiceImpl implements SingletonService,ApplicationContextAware{
    ApplicationContext applicationContext;
    public void start(){
        PrototypeBean prototypeBean = applicationContext.getBean("prototypeBean",PrototypeBean.class);
        prototypeBean.setFoo(new Foo());//output 1
        prototypeBean.setBar(new Bar());//output 2
        process(prototypeBean);

    }
    public void process(PrototypeBean prototypeBean){
        //......
    }
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
      this.applicationContext = applicationContext;
   }
}

方案2：lookup方法注入

​ 该方法利用cglib动态生成一个SingletonServiceImpl的子类，该子类会自动override有lookup注解的方法，代码干净整洁。

@Service(Scope="singleton")
public class SingletonServiceImpl implements SingletonService{

    public void start(){
        PrototypeBean prototypeBean = this.createPrototypeBean();
        prototypeBean.setFoo(new Foo());//output 1
        prototypeBean.setBar(new Bar());//output 2
        process(prototypeBean);

    @Lookup 
    public PrototypeBean createPrototypeBean(){
        return null;//该方法会被cglib自动重写，所以直接返回null就可以。注意方法不能是private，否则cglib不能继承该方法
    }
    //或者
    //@Lookup("prototypeBean")
   // protected abstract Command createPrototypeBean();
    public void process(PrototypeBean prototypeBean){
        //......
    }

xml方式

<!-- 这是个非单例模式的bean -->
<bean id="prototypeBean" class="PrototypeBean" scope="prototype" />
 
<!-- commandProcessor uses statefulCommandHelper -->
<bean id="singletonServiceImpl" class="SingletonServiceImpl">
    <!-- singletonServiceImpl中应该声明抽象方法protected abstract Fruit createPrototypeBean();-->
    <lookup-method name="createPrototypeBean" bean="prototypeBean"/>
</bean>

方案3：使用动态代理

​ spring提供了动态代理，在注入PrototypeBean时会先注入一个PrototypeBean的代理类，等方法调用时，由代理类分配具体的实例，还是先看代码：

@Service(Scope="singleton")
public class SingletonServiceImpl implements SingletonService{
    @Resource
    PrototypeBean prototypeBean;

    public void start(){
        prototypeBean.setFoo(new Foo());
        prototypeBean.setBar(new Bar());
        process(prototypeBean);

    }
    public void process(PrototypeBean prototypeBean){
        //......
    }
}

//如果是接口，就使用ScopeProxyMode.INTERFACES
@Service(Scope="request",proxyMode=ScopeProxyMode.TARGET_CLASS)
public class PrototypeBean{
    private int count = 0;
    private Foo foo;
    private Bar bar;
    public void setFoo(Foo foo){
        this.foo = foo;
        count = count+1;
        System.out.println(count);
    }
    public void setBar(Bar bar){
        this.bar = bar;
        count = count+1;
        System.out.println(count);
    }
}

​ 重点来了，请注意PrototypeBean的注解中，scope我使用了request。为什么不使用prototype呢，因为在动态代理时，如果使用prototype，对prototypeBean中方法的每一次调用，都会生成一个新的prototypeBean实例，如果scope使用prototype，则会出现下面的情况：

public void start(){
        prototypeBean.setFoo(new Foo());//output 1
        prototypeBean.setBar(new Bar());//output 1此时的prototypeBean与上面一行的prototypeBean是两个实例，这样违背了我们希望在start中得到一个新实例的初衷。
        process(prototypeBean);

    }

3、replaced-method

​ 可以在运行时调用新的方法替换现有的方法，还能动态的更新原有方法的逻辑。

​ 使用spaM的reimplement方法替换spaQ的name方法,通过cglib代理

<bean id="spaQ" class="com.dianping.SpaQ">
    <!-- name方法名-->
    <replaced-method name="name" replacer="spaM"/>
</bean>
<bean id="spaM" class="com.dianping.SpaM"/>

​ SpaM必须实现接口import org.springframework.beans.factory.support.MethodReplacer;

public class SpaM implements MethodReplacer {
    @Override
    public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
        System.out.println("I am a singer,name is SpaM");
        return null;
    }
}

4、constructor-arg

​ 对bean自动寻找对应的构造函数，并在初始化的时候将设置的参数传入进去

public class StudentService {
    private String name;
    private Integer age;
    private BookService bookService;
    StudentService(String name, Integer age, BookService bookService){
        this.name = name;
        this.age = age;
        this.bookService = bookService;
    }
}

<bean id="bookService" class="org.springframework.core.service.BookService"/>
<bean id="studentService" class="org.springframework.core.service.StudentService">
    <constructor-arg index="0" value="chenssy"/>
    <constructor-arg name="age" value="100"/>
    <constructor-arg name="bookService" ref="bookService"/>
</bean>

​ StudentService 定义一个构造函数，配置文件中使用 constructor-arg 元素对其配置，该元素可以实现对 StudentService 自动寻找对应的构造函数，并在初始化的时候将值当做参数进行设置。

5、property

5.1基本数据类型赋值

▶name属性：用于指定属性的名称，与类中的set方法后方的名称一致

　　▶value属性：用于指定该属性的值，用于指定的值是基本类型、字符串类型

　　▶ref属性：用于指定该属性的值，用于指定的值是引用对象类型（即其他的Bean），ref后面的值为另一个Bean的id

　　▶value标签：用于指定属性的值，类型为基本类型、字符串类型，值为标签内的文本内容，可以使用null值将属性的值设置为null

　　▶ref标签：用于指定属性的值，类型为引用对象类型，值为其属性的值，其属性有以下三种：

　　　　▷local属性：用于指定依赖本地Bean实例，即同一XML文件中定义的Bean

　　　　▷bean属性：用于指定依赖的Bean实例，可以是不同XML文件中的Bean

　　　　▷parent属性：用于指定依赖的Bean实例，可以是当前BeanFactory或ApplicationContext的父BeanFactory或ApplicationContext中的Bean

<!-- in the child (descendant) context -->
<bean id="accountService" <!-- bean name is the same as the parent bean -->
    class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target">
        <ref parent="accountService"/> <!-- notice how we refer to the parent bean -->
    </property>
    <!-- insert other configuration and dependencies as required here -->
</bean>

　　以下是针对集合的标签

　　▶list标签：用于声明该依赖对象为一个list集合，其下用value和ref标签来指定list中的各值（基本、字符串、对象等）

　　　　▷value标签：用于指定list集合中的值，指定的值为基本类型、字符串类型，值为文本内容

　　　　▷ref标签：用于指定list集合中的引用值，指定的值为其他的对象Bean，其用法与之前property标签下的ref标签的用法相同

　　▶set标签：用于声明该依赖对象为一个set集合，其用法与list标签相同。

　　▶map标签：用于声明该依赖对象为一个map集合，其下用entry标签来声明一个键值对

　　　　▷entry标签：用于声明map集合下的一个键值对，其下用key属性指明键，value/ref标签指明值

　　　　　　→key属性：用于指明键值对中的键，它一般为字符串

　　　　　　→value标签：用于指明键值对中的值，类型为基本类型、字符串类型

　　　　　　→ref标签：用于指明键值对中的值，类型为引用对象类型，即其他的Bean，其用法同之前的ref标签

<bean id="studentService" class="org.springframework.core.service.StudentService">
    <property name="name" value="chenssy"/>
    <property name="age" value="18"/>
</bean>

<bean id="moreComplexObject" class="example.ComplexObject">
    <!-- results in a setAdminEmails(java.util.Properties) call -->
    <property name="adminEmails">
        <props>
            <prop key="administrator">administrator@example.org</prop>
            <prop key="support">support@example.org</prop>
            <prop key="development">development@example.org</prop>
        </props>
    </property>
    <!-- results in a setSomeList(java.util.List) call -->
    <property name="someList">
        <list>
            <value>a list element followed by a reference</value>
            <ref bean="myDataSource" />
        </list>
    </property>
    <!-- results in a setSomeMap(java.util.Map) call -->
    <property name="someMap">
        <map>
            <entry key="an entry" value="just some string"/>
            <entry key ="a ref" value-ref="myDataSource"/>
        </map>
    </property>
    <!-- results in a setSomeSet(java.util.Set) call -->
    <property name="someSet">
        <set>
            <value>just some string</value>
            <ref bean="myDataSource" />
        </set>
    </property>
</bean>

6、qualifier

​ 通过Qualifier指定注入bean的名称

6.1使用说明

@Autowired默认是根据类型进行注入的，因此如果有多个类型一样的Bean候选者，则需要限定其中一个候选者，否则将抛出异常

@Qualifier限定描述符除了能根据名字进行注入，更能进行更细粒度的控制如何选择候选者，具体使用方式如下

//注解使用
@Qualifier(value = "限定标识符")  
字段、方法、参数  

//参数方式
public void initDataSource(@Qualifier("oracleDataSource") DataSource dataSource){
    this.dataSource = dataSource;
}
//方法
@Qualifier(value="oracleDataSource")
public void initDataSource(DataSource dataSource){
	this.dataSource = dataSource;
}

样例

<qualifier  type="org.springframework.beans.factory.annotation.Qualifier"  value="限定标识符"/> 

其中type属性可选，指定类型，默认就是Qualifier注解类，name就是给Bean候选者指定限定标识符，一个Bean定义中只允许指定类型不同的，如果有多个相同type后面指定的将覆盖前面的。

<bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">
	<qualifier value="mysqlDataSource"/>
</bean>
<bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">
	<qualifier value="oracleDataSource"/>
</bean>

6.2、扩展@Qualifier限定描述符注解(不带参数)

​ 对@Qualifier的扩展来提供细粒度选择候选者；

ex:具体使用方式就是自定义一个注解并使用@Qualifier注解其即可使用。

a、场景：

首先让我们考虑这样一个问题，如果我们有两个数据源，分别为Mysql和Oracle，因此注入两者相关资源时就牵扯到数据库相关，如在DAO层注入SessionFactory时，当然可以采用前边介绍的方式，但为了简单和直观我们希望采用自定义注解方式。

b、实现

1,2,创建注解和实用类：

package com.annotation;
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Mysql {
}

package com.annotation;
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Oracle {
}

public class TestBean {
	private DataSource mysqlDataSource;
	private DataSource oracleDataSource;
	@Autowired
	public void initDataSource(@Mysql DataSource mysqlDataSource, @Oracle DataSource oracleDataSource){
		this.mysqlDataSource = mysqlDataSource;
		this.oracleDataSource = oracleDataSource;
	}
	public DataSource getMysqlDataSource() {
		return mysqlDataSource;
	}
	public DataSource getOracleDataSource() {
		return oracleDataSource;
	}
}

3、在Spring配置文件 添加如下Bean配置：

<bean id="testBean" class="com.bean.TestBean"/>

4、在Spring修改定义的两个数据源：

<bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">
	<qualifier value="mysqlDataSource"/>
	<qualifier type="com.annotation.Mysql"/>
</bean>

<bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">
	<qualifier value="oracleDataSource"/>
	<qualifier type="com.annotation.Oracle"/>
</bean> 

5、测试方法如下：

@Test
public void autowiredTest(){
	TestBean bean = ctx.getBean("testBean", TestBean.class);
	DataSource dataSource = bean.getMysqlDataSource();
	if(dataSource instanceof MysqlDriveManagerDataSource){
		System.out.println("mysql");
	}else if(dataSource instanceof OracleDriveManagerDataSource){
		System.out.println("oracle");
	}
	dataSource.connection();
}

6.3、扩展@Qualifier限定描述符注解(带参数)

​ 对@Qualifier的扩展来提供细粒度选择候选者；

前边演示了不带属性的注解，接下来演示一下带参数的注解：

1、首先定义数据库类型：

package com.enumBean;

public enum DataBase {
	ORACLE,MYSQL;
}

2、其次扩展@Qualifier限定描述符注解

package com.annotation;

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})  
@Retention(RetentionPolicy.RUNTIME)  
@Qualifier  
public @interface DataSourceType {
	String ip();    //指定ip,用于多数据源情况
	DataBase database(); //指定数据库类型
}

3、准备测试Bean：

package com.bean;

import org.springframework.beans.factory.annotation.Autowired;

import com.annotation.DataSourceType;
import com.enumBean.DataBase;

public class TestBean {
	
	private DataSource mysqlDataSource;
	
	private DataSource oracleDataSource;

	@Autowired
	public void initDataSource(@DataSourceType(ip="localhost",database=DataBase.MYSQL) DataSource mysqlDataSource, 
				   @DataSourceType(ip="localhost",database=DataBase.ORACLE) DataSource oracleDataSource){
		this.mysqlDataSource = mysqlDataSource;
		this.oracleDataSource = oracleDataSource;
	}
	
	public DataSource getMysqlDataSource() {
		return mysqlDataSource;
	}
	
	public DataSource getOracleDataSource() {
		return oracleDataSource;
	}
}

4、在Spring配置文件 添加如下Bean配置：

<bean id="testBean" class="com.bean.TestBean"/>

5、在Spring修改定义的两个数据源：

<bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">
	<qualifier value="mysqlDataSource"/>
	<qualifier type="com.annotation.DataSourceType">
		<attribute key="ip" value="localhost"/>
		<attribute key="database" value="MYSQL"/>
	</qualifier>
</bean>

<bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">
	<qualifier value="oracleDataSource"/>
	<qualifier type="com.annotation.DataSourceType">
		<attribute key="ip" value="localhost"/>
		<attribute key="database" value="ORACLE"/>
	</qualifier>
</bean> 

6、测试方法如下：

@Test
public void autowiredTest(){
	TestBean bean = ctx.getBean("testBean", TestBean.class);
	DataSource dataSource = bean.getMysqlDataSource();
	if(dataSource instanceof MysqlDriveManagerDataSource){
		System.out.println("mysql");
	}else if(dataSource instanceof OracleDriveManagerDataSource){
		System.out.println("oracle");
	}
	dataSource.connection();
}

测试也通过了，说明我们扩展的@Qualifier限定描述符注解也能很好工作。

三、引用

https://www.programmersought.com/article/26812163811/
https://blog.csdn.net/qq_33374723/article/details/78752364
https://blog.csdn.net/hong10086/article/details/83214554
http://www.webkf.net/article/32/64241.html
https://blog.csdn.net/u011120159/article/details/82218472
http://www.voidcn.com/article/p-vdgrbkrm-bqu.html

赏

谢谢你请我吃糖果

支付宝

微信

• 本文作者： 初心
• 本文链接： http://funzzz.fun/2021/01/04/spring配置参数(IOC)/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！