精华内容
下载资源
问答
  • 主要介绍了Spring @Primary和@Qualifier注解原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • @Qualifier

    千次阅读 2019-06-13 19:33:11
    背景 我们知道,自动装配注入时,可以使用@Resource或者@Autowired注入bean。 但有时候仅仅一个bean_id还无法清晰明确出要注入的bean,因此可以...在class类和bean注入时,都加上@Qualifier(),来达到注入某个...

    https://my.oschina.net/leisu/blog/916051

    背景

            我们知道,自动装配注入时,可以使用@Resource或者@Autowired注入bean。 

            但有时候仅仅一个bean_id还无法清晰明确出要注入的bean,因此可以引入@Qualifier注解。在class类和bean注入时,都加上@Qualifier(),来达到注入某个特指bean的作用

     

    1.  @Qualifier

            实例如下:

    //定义亚洲人
    @Qualifier("Asian")
    @Component
    public class AsianMan extends Person {
    
    }
    
    ········
    
    //定义欧洲人
    @Qualifier("Europe")
    @Component
    public class EuropeMan extends Person {
    
    }

    注入bean时,可以使用@Autowired自动注入 

    public class Controller {
    
        @Qualifier("Asian")      //指定注入的是Asain的bean
        @Autowired
        private Person person;
    
    }

    也可以使用xml配置

    <bean id="controller" class="org.leisu.Controller">
       <qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="Asian"/>
    </bean>

        可以看到,在生成两个继承了Person的bean时,通过@Qualifier()注解指定了两个bean的特征,分别为:“Asian“、”Europe“;在注入bean时,静态类型是父类Person,通过@Qualifier()指定注入的bean为”Asian“

    2.  bean已有id,为什么还用@Qualifier?

          上面的例子,我们可以把两个bean的id分别设为“Asian“、”Europe“,然后用@Resource(name="***")也同样能实现相关功能,那为什么还要用@Qualifier?

            个人理解@Qualifier是个修饰词,不需要bean_id不可重复那么严格,比较灵活。那么就可以把其中的参数作为一种修饰,作为bean的形容词来进行更细致的描述。在《Spring实战》书中,举例是类IceCream(冰淇淋)和Dessert(甜点)都用@Qualifier(”cold“)来修饰,意思是凉的冰淇淋和甜点。

            因此使用@Qualifier,更加灵活,也更符合面向对象的思想。

    2.  @Qualifier加在注解上

        上面的例子中,可以看到是使用@Qualifier()中value的参数来筛选bean的,本文给此参数起个名字,叫做修饰语。修饰语是字符串类型,可以设置各种值。

            如果一个工程的修饰语种类特别多,或者修饰语语义之间有继承等类似复杂关系,或者需要用多个修饰语修饰同一个bean,那用这种直接的方式就不太好操作了。修饰语value字符串容易拼错,容易混淆,更不容易被编辑器检测出来,调试bug困难。

            因此可以自定义一个新的注解,使用@Qualifier修饰,制作自己的修饰语注解

    @Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Qualifier("Asian")         //使用@Qualifier自定义修饰注解Asian
    public @interface Asian{ ... }
    
    ···············
    
    //定义亚洲人
    @Asian          //使用我们自定义的修饰注解
    @Component
    public class AsianMan extends Person {
    
    }
    

    注入 

    public class Controller {
    
        @Asian       //指定注入的是Asain的bean
        @Autowired
        private Person person;
    
    }

     

    展开全文
  • 在SpringBoot整合Druid数据库连接池时候,配置主从库数据源,使用@Qualifier注解进行注入Bean时候,编译错误,提示: The annotation @Qualifier is disallowed for this location 错误原因: import导入的包...

    问题描述:

    在SpringBoot整合Druid数据库连接池时候,配置主从库数据源,使用@Qualifier注解进行注入Bean时候,编译错误,提示:

    The annotation @Qualifier is disallowed for this location

    错误原因:

    • import导入的包错误,导入了:import org.mapstruct.Qualifier;
    import org.mapstruct.Qualifier;

     解决方案:

    • 导入spring下的包
    import org.springframework.beans.factory.annotation.Qualifier;

    注意:eclipse使用快捷键【ctrl+shift+o】导入包的时候,多个包时候,会弹框提示,此时选择自己需要导入的包。

    展开全文
  • @Qualifier的作用和应用

    2021-04-29 00:54:46
    来源:blog.csdn.net/qq_30062181/article/details/107619529@Qualifier的作用这是官方的介绍This annotation may ...

    来源:blog.csdn.net/qq_30062181/article/details/107619529

    @Qualifier的作用

    这是官方的介绍

    This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring. It may also be used to annotate other custom annotations that can then in turn be used as qualifiers.

    简单的理解就是:

    • 在使用@Autowire自动注入的时候,加上@Qualifier(“test”)可以指定注入哪个对象;

    • 可以作为筛选的限定符,我们在做自定义注解时可以在其定义上增加@Qualifier,用来筛选需要的对象。这个理解看下面的代码吧,不好解释。

    功能介绍

    首先是对(1)的理解。

    //我们定义了两个TestClass对象,分别是testClass1和testClass2
    //我们如果在另外一个对象中直接使用@Autowire去注入的话,spring肯定不知道使用哪个对象
    //会排除异常 required a single bean, but 2 were found
    @Configuration
    public class TestConfiguration {
       @Bean("testClass1")
       TestClass testClass1(){
           return new TestClass("TestClass1");
       }
       @Bean("testClass2")
       TestClass testClass2(){
           return new TestClass("TestClass2");
       }
    }
    

    下面是正常的引用

    @RestController
    public class TestController {
    
        //此时这两个注解的连用就类似 @Resource(name="testClass1")
        @Autowired
        @Qualifier("testClass1")
        private TestClass testClass;
    
        @GetMapping("/test")
        public Object test(){
            return testClassList;
        }
    
    }
    

    @Autowired和@Qualifier这两个注解的连用在这个位置就类似 @Resource(name=“testClass1”)

    对(2)的理解

    @Configuration
    public class TestConfiguration {
        //我们调整下在testClass1上增加@Qualifier注解
        @Qualifier
        @Bean("testClass1")
        TestClass testClass1(){
            return new TestClass("TestClass1");
        }
    
        @Bean("testClass2")
        TestClass testClass2(){
            return new TestClass("TestClass2");
        }
    }
    
    @RestController
    public class TestController {
        //我们这里使用一个list去接收testClass的对象
        @Autowired
        List<TestClass> testClassList= Collections.emptyList();
        
        @GetMapping("/test")
        public Object test(){
            return testClassList;
        }
    }
    

    我们调用得到的结果是

    [
         {
            "name": "TestClass1"
         },
        {
           "name": "TestClass2"
        }
    ]
    

    我们可以看到所有的testclass都获取到了。接下来我们修改下代码

    @RestController
    public class TestController {
    
        @Qualifier //我们在这增加注解
        @Autowired
        List<TestClass> testClassList= Collections.emptyList();
    
        @GetMapping("/test")
        public Object test(){
            return testClassList;
        }
    }
    

    和上面代码对比就是在接收参数上增加了@Qualifier注解,这样看是有什么区别,我们调用下,结果如下:

    [
         {
            "name": "TestClass1"
         }
    ]
    

    返回结果只剩下增加了@Qualifier注解的TestClass对象,这样我们就可以理解官方说的标记筛选是什么意思了。

    另外,@Qualifier注解是可以指定value的,这样我们可以通过values来分类筛选想要的对象了,这里不列举代码了,感兴趣的同学自己试试。

    推荐好文

    强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

    分享一套基于SpringBoot和Vue的企业级中后台开源项目,代码很规范!

    能挣钱的,开源 SpringBoot 商城系统,功能超全,超漂亮

    展开全文
  • @Qualifier注解

    千次阅读 2019-02-12 14:52:44
    @Autowired是根据类型进行自动装配的。如果当spring上下文中存在不止一个UserDao类型的bean时,就会抛出...我们可以使用@Qualifier配合@Autowired来解决这些问题。如下: ①可能存在多个UserDao实...

    @Autowired是根据类型进行自动装配的。如果当spring上下文中存在不止一个UserDao类型的bean时,就会抛出BeanCreationException异常;如果Spring上下文中不存在UserDao类型的bean,也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。如下:

    ①可能存在多个UserDao实例

     

    [java] view plain copy

    1. @Autowired   
    2. @Qualifier("userServiceImpl")   
    3. public IUserService userService;   

     

    或者

    [java] view plain copy

    1. @Autowired   
    2. public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
    3.     this.userDao = userDao;   
    4. }  

     

    这样Spring会找到id为userServiceImpl和userDao的bean进行装配。

     

    ②可能不存在UserDao实例

     

    [java] view plain copy

    1. @Autowired(required = false)   
    2. public IUserService userService  

     

     

    三、@Qualifier:限定描述符,用于细粒度选择候选者;

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

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

     

     
    1. @Qualifier(value = "限定标识符")

    2. 字段、方法、参数

     

    (1)、根据基于XML配置中的<qualifier>标签指定的名字进行注入,使用如下方式指定名称:

     

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

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

    1、准备测试Bean:

    DataSource.java

     

     
    1. package com.bean;

    2.  
    3. public interface DataSource {

    4.  
    5. public void connection();

    6. }

    MysqlDriveManagerDataSource.java

     

     
    1. package com.bean;

    2.  
    3. public class MysqlDriveManagerDataSource implements DataSource{

    4.  
    5. public void connection() {

    6. System.out.println("mysql database connecting...");

    7. }

    8.  
    9. }

    OracleDriveManagerDataSource.java

     

     
    1. package com.bean;

    2.  
    3. public class OracleDriveManagerDataSource implements DataSource{

    4.  
    5. public void connection() {

    6. System.out.println("oracle database connecting...");

    7. }

    8.  
    9. }

    TestBean.java

     

     
    1. package com.bean;

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

    4. import org.springframework.beans.factory.annotation.Qualifier;

    5.  
    6.  
    7. public class TestBean {

    8.  
    9. private DataSource dataSource;

    10.  
    11. @Autowired

    12. public void initDataSource(@Qualifier("oracleDataSource") DataSource dataSource){

    13. this.dataSource = dataSource;

    14. }

    15.  
    16. public DataSource getDataSource() {

    17. return dataSource;

    18. }

    19. }

    其中TestBean.java中使用 @Qualifier还有一种方式

     

     
    1. @Autowired

    2. @Qualifier(value="oracleDataSource")

    3. public void initDataSource(DataSource dataSource){

    4. this.dataSource = dataSource;

    5. }

     

    2、在Spring配置文件 添加如下Bean配置:

     

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

    我们使用@Qualifier("oracleDataSource")来指定候选Bean的限定标识符,我们需要在配置文件中使用<qualifier>标签来指定候选Bean的限定标识符“oracleDataSource”:

     

     
    1. <bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">

    2. <qualifier value="mysqlDataSource"/>

    3. </bean>

    4.  
    5. <bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">

    6. <qualifier value="oracleDataSource"/>

    7. </bean>

    3、测试方法如下:

     

     
    1. @Test

    2. public void autowiredTest(){

    3. TestBean bean = ctx.getBean("testBean", TestBean.class);

    4. DataSource dataSource = bean.getDataSource();

    5. if(dataSource instanceof MysqlDriveManagerDataSource){

    6. System.out.println("mysql");

    7. }else if(dataSource instanceof OracleDriveManagerDataSource){

    8. System.out.println("oracle");

    9. }

    10. dataSource.connection();

    11.  
    12. try{

    13. ctx.getBean("mysqlDataSource");

    14. }catch(Exception e){

    15. if(e instanceof NoSuchBeanDefinitionException){

    16. System.out.println("@Qualifier不能作为Bean的标识符");

    17. }

    18. e.printStackTrace();

    19. }

    20. }

    从测试可以看出使用<qualifier>标签指定的限定标识符只能被@Qualifier使用,不能作为Bean的标识符,如“ctx.getBean("mysqlDataSource")”是获取不到Bean的。

     

     

    (2)、缺省的根据Bean名字注入最基本方式,是在Bean上没有指定<qualifier>标签时一种容错机制,即缺省情况下使用Bean标识符注入,但如果你指定了<qualifier>标签将不会发生容错。

    1、准备测试Bean:

     

     
    1. package com.bean;

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

    4. import org.springframework.beans.factory.annotation.Qualifier;

    5.  
    6.  
    7. public class TestBean {

    8.  
    9. private DataSource dataSource;

    10.  
    11. @Autowired

    12. @Qualifier(value="mysqlDataSourceBean")

    13. public void initDataSource(DataSource dataSource){

    14. this.dataSource = dataSource;

    15. }

    16.  
    17. public DataSource getDataSource() {

    18. return dataSource;

    19. }

    20. }

     

    2、在Spring配置文件 添加如下Bean配置:

     

     
    1. <bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource"/>

    2. <bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource"/>

    3、测试方法如下:

     

     
    1. @Test

    2. public void autowiredTest(){

    3. TestBean bean = ctx.getBean("testBean", TestBean.class);

    4. DataSource dataSource = bean.getDataSource();

    5. if(dataSource instanceof MysqlDriveManagerDataSource){

    6. System.out.println("mysql");

    7. }else if(dataSource instanceof OracleDriveManagerDataSource){

    8. System.out.println("oracle");

    9. }

    10. dataSource.connection();

    11.  
    12. }

    因为配置文件中并没有使用 @Qualifier标签 所以我们在bean中注入的时候是注入 bean  

    @Qualifier(value="mysqlDataSourceBean")

     

     

    (3)、扩展@Qualifier限定描述符注解(不带参数):对@Qualifier的扩展来提供细粒度选择候选者;
     

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

     

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

     

    1、扩展@Qualifier限定描述符注解来分别表示Mysql和Oracle数据源

     

     
    1. package com.annotation;

    2.  
    3. import java.lang.annotation.ElementType;

    4. import java.lang.annotation.Retention;

    5. import java.lang.annotation.RetentionPolicy;

    6. import java.lang.annotation.Target;

    7.  
    8. import org.springframework.beans.factory.annotation.Qualifier;

    9.  
    10. @Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER})

    11. @Retention(RetentionPolicy.RUNTIME)

    12. @Qualifier

    13. public @interface Mysql {

    14. }

     
    1. package com.annotation;

    2.  
    3. import java.lang.annotation.ElementType;

    4. import java.lang.annotation.Retention;

    5. import java.lang.annotation.RetentionPolicy;

    6. import java.lang.annotation.Target;

    7.  
    8. import org.springframework.beans.factory.annotation.Qualifier;

    9.  
    10. @Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER})

    11. @Retention(RetentionPolicy.RUNTIME)

    12. @Qualifier

    13. public @interface Oracle {

    14. }

     

    2、准备测试Bean:

     

     
    1. package com.bean;

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

    4.  
    5. import com.annotation.Mysql;

    6. import com.annotation.Oracle;

    7.  
    8. public class TestBean {

    9.  
    10. private DataSource mysqlDataSource;

    11.  
    12. private DataSource oracleDataSource;

    13.  
    14. @Autowired

    15. public void initDataSource(@Mysql DataSource mysqlDataSource, @Oracle DataSource oracleDataSource){

    16. this.mysqlDataSource = mysqlDataSource;

    17. this.oracleDataSource = oracleDataSource;

    18. }

    19.  
    20. public DataSource getMysqlDataSource() {

    21. return mysqlDataSource;

    22. }

    23.  
    24. public DataSource getOracleDataSource() {

    25. return oracleDataSource;

    26. }

    27. }

     

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

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

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

     

     
    1. <bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">

    2. <qualifier value="mysqlDataSource"/>

    3. <qualifier type="com.annotation.Mysql"/>

    4. </bean>

    5.  
    6. <bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">

    7. <qualifier value="oracleDataSource"/>

    8. <qualifier type="com.annotation.Oracle"/>

    9. </bean>

    5、测试方法如下:

     

     
    1. @Test

    2. public void autowiredTest(){

    3. TestBean bean = ctx.getBean("testBean", TestBean.class);

    4. DataSource dataSource = bean.getMysqlDataSource();

    5. if(dataSource instanceof MysqlDriveManagerDataSource){

    6. System.out.println("mysql");

    7. }else if(dataSource instanceof OracleDriveManagerDataSource){

    8. System.out.println("oracle");

    9. }

    10. dataSource.connection();

    11. }

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

     

     

    (3)、扩展@Qualifier限定描述符注解(带参数):对@Qualifier的扩展来提供细粒度选择候选者;

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

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

     

     
    1. package com.enumBean;

    2.  
    3. public enum DataBase {

    4. ORACLE,MYSQL;

    5. }

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

     

     
    1. package com.annotation;

    2.  
    3. import java.lang.annotation.ElementType;

    4. import java.lang.annotation.Retention;

    5. import java.lang.annotation.RetentionPolicy;

    6. import java.lang.annotation.Target;

    7.  
    8. import org.springframework.beans.factory.annotation.Qualifier;

    9.  
    10. import com.enumBean.DataBase;

    11.  
    12. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})

    13. @Retention(RetentionPolicy.RUNTIME)

    14. @Qualifier

    15. public @interface DataSourceType {

    16. String ip(); //指定ip,用于多数据源情况

    17. DataBase database(); //指定数据库类型

    18. }

    3、准备测试Bean:

     

     
    1. package com.bean;

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

    4.  
    5. import com.annotation.DataSourceType;

    6. import com.enumBean.DataBase;

    7.  
    8. public class TestBean {

    9.  
    10. private DataSource mysqlDataSource;

    11.  
    12. private DataSource oracleDataSource;

    13.  
    14. @Autowired

    15. public void initDataSource(@DataSourceType(ip="localhost",database=DataBase.MYSQL) DataSource mysqlDataSource,

    16. @DataSourceType(ip="localhost",database=DataBase.ORACLE) DataSource oracleDataSource){

    17. this.mysqlDataSource = mysqlDataSource;

    18. this.oracleDataSource = oracleDataSource;

    19. }

    20.  
    21. public DataSource getMysqlDataSource() {

    22. return mysqlDataSource;

    23. }

    24.  
    25. public DataSource getOracleDataSource() {

    26. return oracleDataSource;

    27. }

    28. }

     

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

     

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

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

     

     
    1. <bean id="mysqlDataSourceBean" class="com.bean.MysqlDriveManagerDataSource">

    2. <qualifier value="mysqlDataSource"/>

    3. <qualifier type="com.annotation.DataSourceType">

    4. <attribute key="ip" value="localhost"/>

    5. <attribute key="database" value="MYSQL"/>

    6. </qualifier>

    7. </bean>

    8.  
    9. <bean id="oracleDataSourceBean" class="com.bean.OracleDriveManagerDataSource">

    10. <qualifier value="oracleDataSource"/>

    11. <qualifier type="com.annotation.DataSourceType">

    12. <attribute key="ip" value="localhost"/>

    13. <attribute key="database" value="ORACLE"/>

    14. </qualifier>

    15. </bean>

     

    6、测试方法如下:

     

     
    1. @Test

    2. public void autowiredTest(){

    3. TestBean bean = ctx.getBean("testBean", TestBean.class);

    4. DataSource dataSource = bean.getMysqlDataSource();

    5. if(dataSource instanceof MysqlDriveManagerDataSource){

    6. System.out.println("mysql");

    7. }else if(dataSource instanceof OracleDriveManagerDataSource){

    8. System.out.println("oracle");

    9. }

    10. dataSource.connection();

    11. }

     转载地址:https://blog.csdn.net/qq_38989725/article/details/76592791

    https://blog.csdn.net/lovin_fang/article/details/78537547

    展开全文
  • } } @qualifier注解 @Qualifier限定哪个bean应该被自动注入。当Spring无法判断出哪个bean应该被注入时,@Qualifier注解有助于消除歧义bean的自动注入。参见下面的例子 public class Staff{ @Autowired private ...
  • 今天带你了解一下Spring框架中的@Qualifier注解,它解决了哪些问题,以及如何使用它。我们还将了解它与@Primary注解的不同之处。更多的技术解析请访问felord.cn 2. 痛点 使用@Autowired注解是Spring依赖注入的绝好...
  • @Autowire、@Resource、@Qualifier的区别一、简单说明@Autowire@Resource@Qualifier二、场景示例1、场景一(接口只有一个实现类)2、场景二(接口有多个实现类) 一、简单说明 这三个注解的作用都是用来注入依赖对象...
  • Spring框架中的@Qualifier注解和@primary注解,它解决了哪些问题,以及如何使用它。我们还将了解它与@Primary注解的不同之处。 2. 痛点 使用@Autowired注解是Spring依赖注入的绝好方法。但是有些场景下仅仅靠这个...
  • } 2 @Qualifier @Qualifier 是根据属性名称进行注入。 @Qualifier 注解的使用,需要和上面 @Autowired 一起使用。 Tips:有时候一个接口会有多个实现类,因此就必须要用 @Qualifier 注解根据名称来说明到底要注入哪...
  • 首先阐述 @Autowired 和 @Resource 的区别 @Resource 是JDK自带的注解 可以按名称注入也可以按...@Autowired 结合 @Qualifier() 实现按名称注入时,是按@Qualifier() 定义的名称注入的 @Primary 当需要注入多个同类型的
  • Spring Cloud 之@LoadBalanced注解,看完保证你还懂@Qualifier注解 在使用Spring Cloud Ribbon客户端进行负载均衡的时候,可以给RestTemplate(Bean) 加一个@LoadBalanced注解,就能让这个RestTemplate在请求时拥有...
  • spring中@Qualifier注解的两种用法spring源码中的@Qualifier第一种用法第二种用法Ribbon中使用了@Qualifier的第二种用法 spring源码中的@Qualifier /** * This annotation may be used on a field or parameter as ...
  • @Qualifier用处

    2020-02-02 22:10:42
    @Qualifier用处 ...
  • @Qualifier作用: 通过使用 @Qualifier 注解,我们可以消除需要注入哪个 bean 的问题。用来解决歧义。 在写配置类的时候,自己的@Qualifier注解老是不生效,报Error creating bean with name ...
  • @Qualifier注解作用

    千次阅读 2020-10-21 00:28:46
    @Qualifier 注解作用就是为了给Bean打上一个标记,用来和其他的Bean做区分,代码示例: ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201021002048346.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5...
  • 首先明确一点:@Autowired @Qualifier 属于 Spring 定义的注解,@Resource 属于 JSR-250 规范定义的注解。以上注解 Spring 都支持。文章仅代表个人观点,如有不正之处,欢迎批评指正。 @Autowired 根据 bean ...
  • } } @Qualifier("Asian") @Component public class AsianMan extends Person{ @Override public void eat(String food) { System.out.println("Asian"); System.out.println("黄种人"); System.out.println(food); ...
  • @Qualifier的作用

    万次阅读 多人点赞 2019-11-22 10:07:37
    Qualifier的意思是合格者,通过这个标示,表明了哪个实现类才是我们所需要的; @Autowired默认按照类型匹配注入bean,如果有多个实现类,搭配@Qualifier(“实现类名称”)表明注入的是哪一个实现类的bean: 比如: ...
  • @Autowired和@Qualifier

    2020-10-26 21:58:52
    @Autowired 默认是按照类去匹配,配合 @Qualifier 指定按照名称去装配 bean。 可以这样理解为何需要@Autowired注入,以及@Autowired注释的作用spring可以自动帮你把Bean里面引用的对象的setter/getter方法省略,它...
  • ,那么这个类型的bean一定是唯一的,组件下的唯一bean,不存在@qualifier这种事情   @Conditional(OnBeanCondition.class) public @interface ConditionalOnMissingBean { OnBeanCondition @Order...
  • Spring中的@Qualifier注解

    2020-07-04 11:45:45
    本文将带你来了解一下Spring中的@Qualifier注解,它解决了哪些问题,以及如何使用它。我们还将了解它与@Primary注解的不同之处。 使用@Autowired注解是Spring依赖注入的绝好方法。但是有些场景下仅仅靠这个注解不...
  • @Qualifier注解的使用

    千次阅读 2020-08-29 10:13:59
    @Qualifier这个注解很简单。就是你一个接口有多个实现类。在Spring中使用了 @Autowired自动注入的时候不知道怎么选择是哪个具体的实现类了。 例如UserDao有2个实现类。 ** ** 如果你是Spring容器,给你一个UserDao...
  • 简述 虽然lombok 有很多缺点,但确实会减少很多代码。在Spring 中使用lombok 可以让注入... @Qualifier("curtaoRestClient") private final RestHighLevelClient restClient; private final ConstructorEsUtil constr
  • @Qualifier用来配合@Autowired自动装配使用,用于指定不一样的值 @Autowired默认可以不写,自动按类型或名称装配,遇到多个JavaBean或者自定义xml中配置名称时使用@Qualifier JavaBean中配置 @Qualifier(value = ...
  • @Autowired @Resource @Qualifier的区别

    千次阅读 2019-06-25 11:57:29
    @Autowired @Resource @Qualifier的区别 @Autowired 注释进行自动注入是,Spring容器中匹配的候选Bean数量必须只有一个,当找不到一个匹配的Bean时候,Spring容器抛出BeanCreationException一次,并且指出至少拥有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,710
精华内容 31,484
关键字:

@Qualifier