[email protected]&@Qualifier和@Primary

@Autowried是Spring2.5定義的自動裝配的註解,它可以對類成員變數、方法及建構函式進行標註，完成自動裝配的工作。 使用 @Autowired的使用來消除 set ，get方法。@Autowired 標註在方法上表示當前方法的自定義引數從容器中賦值，ioc容器預設賦值時，需要呼叫無參構造器後，再進行預設賦值，如果當前類只有一個有參的構造器，則@Autwried可以省略，並且該構造器的引數也預設從ioc容器中獲取。

我們建立Color介面、以及它的實現類Red和Bule來介紹@Autowried&@Qualifier和@Primary的用法

Color介面

public interface Color {
}

Red實現類

@Component
public class Red implements Color {
    public Red() {
        System.out.println("這是Red的 構造器");

    }
}

Flower類

@Component
public class Flower {
    @Autowired
    private Color color;

    @Override
    public String toString
 
() {
        return "Folwer{" +"color=" + color +'}';
    }
}

配置類 AutowriedConfig

@Configuration
@ComponentScan("com.daxiong.pojo.Autowired")
public class AutowriedConfig {
}

測試類

public class AutowriedConfigTest {
    private AnnotationConfigApplicationContext  annotationConfigApplicationContext = new
 
 AnnotationConfigApplicationContext(AutowriedConfig.class);

    @Test
    public void testAutowired1() {
        Flower bean = annotationConfigApplicationContext.getBean(Flower.class);
        System.out.println(bean);
    }
}

此時我們只在Spring容器中注入的一個Color的實現類Red，測試結果

新增Bule類

@Component
public class Bule implements Color {
    public Bule() {
        System.out.println("這是Bule 的 構造器");
    }
}

執行結果：

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'flower': Unsatisfied dependency expressed through field 'color'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.daxiong.pojo.Autowired.Color' available: expected single matching bean but found 2: bule,red
.....
Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.daxiong.pojo.Autowired.Color' available: expected single matching bean but found 2: bule,red

出現No qualifying bean of type ‘com.daxiong.pojo.Autowired.Color’ available的異常，原因是@Autowried是按照型別注入的，我們在Flower中注入的Color物件沒有指定型別，Spring容器不知道到底應該注入哪一個物件的原因。解決辦法有以下幾種方法：

1. 使用@Qualifier註解，明確的指定注入型別

   @Qualifier(value="red")
   private Color color;

   ​

2. 使用@Primary註解，預設指定的型別

   @Primary
   @Component
   public class Red implements Color {
      public Red() {
          System.out.println("這是Red的 構造器");
   
      }
   }

3. 修改引數名

   @Component
   public class Flower {
       //修改color的屬性名為red
      @Autowired
      private Color red;
   
      @Override
      public String toString() {
          return "Folwer{" +"color=" + red +'}';
      }
   

   執行結果：

   

注意點：

如果在自動裝配時。Spring容器中沒有註冊對應的Bean，就會報錯

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.daxiong.pojo.Autowired.Color' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}

我們也只需要在@Autowried後加上(required=true)即可

[email protected]&@Inject

@Resource和@Inject分別是在JSR250和JSR330規範中定義的註解，在Spring中也得到了支援使用方法和@Autowried的類似

@Resource預設是按照屬性來裝配的，沒有支援@Primary和reuired

@Inject支援@Primary，但時不支援reuired，需要匯入javax.Inject包

3.Aware注入Spring底層元件&原理

自定義元件想要使用Spring容器底層的一些元件比如ApplicationContext，BeanFactory，等等，都可以通過實現XXXAware，在建立物件時，會把呼叫介面規定的方法把指定的元件裝配進去。

實現原理，這些XXXAware介面，都有對應的XXXprocessor來處理

如ApplicationContextAware有ApplicationContextAwareProcessor來處理Spring原始碼：

 //實現了BeanPostProcessor介面，所以會在元件初始化的識貨呼叫
class ApplicationContextAwareProcessor implements BeanPostProcessor {
  //在元件賦值前呼叫 
  @Override
   public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
      AccessControlContext acc = null;
     //判斷是否為對應介面型別
      if (System.getSecurityManager() != null &&
            (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                  bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                  bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
         acc = this.applicationContext.getBeanFactory().getAccessControlContext();
      }

      if (acc != null) {
         AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
               invokeAwareInterfaces(bean);
               return null;
            }
         }, acc);
      }
      else {
        //進行賦值操作
         invokeAwareInterfaces(bean);
      }

      return bean;
   }

   private void invokeAwareInterfaces(Object bean) {
     //對應的介面進行賦值操作
      if (bean instanceof Aware) {
         if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
         }
         if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
         }
         if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
         }
         if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
         }
         if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
         }
         if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
         }
      }
   }
}