怎么在Spring IOC中利用注解啟動(dòng)？相信很多沒(méi)有經(jīng)驗(yàn)的人對(duì)此束手無(wú)策，為此本文總結(jié)了問(wèn)題出現(xiàn)的原因和解決方法，通過(guò)這篇文章希望你能解決這個(gè)問(wèn)題。

創(chuàng)新互聯(lián)專注于佳木斯企業(yè)網(wǎng)站建設(shè),成都響應(yīng)式網(wǎng)站建設(shè)公司,商城網(wǎng)站制作。佳木斯網(wǎng)站建設(shè)公司,為佳木斯等地區(qū)提供建站服務(wù)。全流程定制網(wǎng)站制作，專業(yè)設(shè)計(jì)，全程項(xiàng)目跟蹤，創(chuàng)新互聯(lián)專業(yè)和態(tài)度為您提供的服務(wù)

Spring 基于注解啟動(dòng)

主要有兩個(gè)Class實(shí)現(xiàn)注解啟動(dòng)

• AnnotationConfigApplicationContext

• AnnotationConfigWebApplicationContext

我們以AnnotationConfigApplicationContext 為研究對(duì)象

AnnotationConfigApplicationContext.png

引入Spring 最小依賴

 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>${spring.version}</version>
 </dependency>

編寫器啟動(dòng)代碼

 public static void main(String[] args) {
 AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
 applicationContext.register(BeanConfig.class);
 applicationContext.refresh();
 Date date = applicationContext.getBean("date",Date.class);
 System.out.println(date);
 }

AnnotationConfigApplicationContext 構(gòu)造函數(shù)

 public AnnotationConfigApplicationContext() {
    //負(fù)責(zé)注冊(cè)Class ，讀取器
  this.reader = new AnnotatedBeanDefinitionReader(this);
    //負(fù)責(zé)掃描指定類路徑下的Class，注冊(cè)bean
  this.scanner = new ClassPathBeanDefinitionScanner(this);
 }

AnnotatedBeanDefinitionReader 構(gòu)造方法

 public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
  this(registry, getOrCreateEnvironment(registry));
 }

 public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
  Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  Assert.notNull(environment, "Environment must not be null");
  this.registry = registry;
    //初始化ConditionEvaluator
  this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
     
  /** 在給定的注冊(cè)表中註冊(cè)所有相關(guān)的post processors
   * 判斷容器是否已經(jīng)存在給定注冊(cè)表的bean，如果沒(méi)有注冊(cè)bean，并將bean放入容器中
   * 把所有的處理處理器列出來(lái)
   * ConfigurationClassPostProcessor 內(nèi)部管理的配置注解處理器
   * AutowiredAnnotationBeanPostProcessor 內(nèi)部管理@Autowired 的處理器
   * RequiredAnnotationBeanPostProcessor @Required的處理器
   * CommonAnnotationBeanPostProcessor JSR-250注解處理器 ，先判斷是否支持jsr，如果支持注冊(cè)
   * PersistenceAnnotationBeanPostProcessor JPA管理 先使用類加載器查找是否存在，如果有這個(gè)包則注冊(cè)
   * EventListenerMethodProcessor @EventListener的處理器
   * DefaultEventListenerFactory 管理EventListenerFactory處理器
   */
  AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
 }

ConditionEvaluator 這個(gè)對(duì)象干什么,點(diǎn)擊進(jìn)去

 public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
   @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

  this.context = new ConditionContextImpl(registry, environment, resourceLoader); 
 }
  //ConditionContextImpl 實(shí)現(xiàn)了ConditionContext接口，ConditionEvaluator靜態(tài)內(nèi)部類
  public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
    @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

   this.registry = registry;
   this.beanFactory = deduceBeanFactory(registry);
   this.environment = (environment != null ? environment : deduceEnvironment(registry));
   this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
   this.classLoader = deduceClassLoader(resourceLoader, this.beanFactory);
  }

可以知道ConditionEvaluator使用外部傳參的方法初始化了Spring容器頂級(jí)對(duì)象
BeanFactory,Environment,ResourceLoader,ClassLoader。在將這些傳給ConditionContextImpl為接下來(lái)的解析@Conditional注解做好準(zhǔn)備

ClassPathBeanDefinitionScanner構(gòu)造函數(shù)

 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
  this(registry, true);
 }

 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
  this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
 }

 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
   Environment environment) {
  this(registry, useDefaultFilters, environment,
    (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
 }

 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
   Environment environment, @Nullable ResourceLoader resourceLoader) {
  Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  this.registry = registry;
  if (useDefaultFilters) {
   registerDefaultFilters();
  }
  setEnvironment(environment);
  setResourceLoader(resourceLoader);
 }

 protected void registerDefaultFilters() {
  this.includeFilters.add(new AnnotationTypeFilter(Component.class));
  ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
  try {
   this.includeFilters.add(new AnnotationTypeFilter(
     ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
   logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
  }
  catch (ClassNotFoundException ex) {
  }
  try {
   this.includeFilters.add(new AnnotationTypeFilter(
     ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
   logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
  }
  catch (ClassNotFoundException ex) {
   // JSR-330 API not available - simply skip.
  }
 }

繞了地球幾圈了，其實(shí)就是將Spring 頂級(jí)接口 Environment,ResourceLoader賦值，使用默認(rèn)注解過(guò)濾器，首先將@Component加入List中，判斷當(dāng)前環(huán)境是否支持JSR-250，JSR-330，相應(yīng)加入過(guò)濾器中。也就是這個(gè)掃描器默認(rèn)只掃描@Component或者JSR-250，JSR-330的標(biāo)記的Class。

applicationContext.register(BeanConfig.class)

 public void register(Class<?>... annotatedClasses) {
  Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
  this.reader.register(annotatedClasses); //調(diào)用 剛剛初始化讀取器
 }
           |
============================AnnotatedBeanDefinitionReader 讀取器代碼======================================================================================================
  public void register(Class<?>... annotatedClasses) {
  for (Class<?> annotatedClass : annotatedClasses) {
   registerBean(annotatedClass);
  }
  }

 public void registerBean(Class<?> annotatedClass) {
  doRegisterBean(annotatedClass, null, null, null);
 }
  
 /**
 *從給定的bean解析Class給定的注解，執(zhí)行相應(yīng)的初始化，保存到Spring容器中
 */
 <T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
   @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

  //根據(jù)Class的Annotated 得出元數(shù)據(jù) AnnotationMetadata
  AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
  /**
  * 判斷注冊(cè)的Class 是否包含@Conditional注解，如果有獲取全部value，放入List中
  * 排序后，遍歷所有的Conditiion的實(shí)現(xiàn)，使用反射獲取對(duì)象，執(zhí)行matches方法，
  * 如果發(fā)現(xiàn)有返回false，中斷循環(huán)直接返回true，
  */
  if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { //如果 @Conditional條件不滿足，不進(jìn)行注冊(cè)
   return;
  }

  abd.setInstanceSupplier(instanceSupplier);
  //解析Class是否有@Scope,解析@Scope注解返回ScopeMetadata對(duì)象，沒(méi)有直接返回空
  ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  abd.setScope(scopeMetadata.getScopeName());
  //判斷注解上Value是否有值，有就使用這個(gè)作為BeanName，沒(méi)有則取類名 
  String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  //繼續(xù)解析AnnotationMetadata的@Lazy,@Primary，@DependsOn，@Role，@Description的注解，放入結(jié)果放入對(duì)象的屬性中
  AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
  //這個(gè)類只是BeanDefinition 包裝類
  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  //是否需要代理類，如果是則修改內(nèi)部屬性，重新生成BeanDefinition 對(duì)象
  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  //調(diào)用DefaultListableBeanFactory.registerBeanDefinition的方法，做一些安全性校驗(yàn)再，將definitionHolder 放入register容器中
  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
 }

這個(gè)方法就是將注冊(cè)的Bean，解析Class上的注解，初始化注解數(shù)據(jù)，做相應(yīng)處理，轉(zhuǎn)化成BeanDefinition ,放入Spring 容器中保存起來(lái)。

我們看下BeanDefinition是怎么實(shí)現(xiàn)注冊(cè)到Spring的容器中，主要由DefaultListableBeanFactory.registerBeanDefinition來(lái)實(shí)現(xiàn)

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
   throws BeanDefinitionStoreException {

  Assert.hasText(beanName, "Bean name must not be empty");
  Assert.notNull(beanDefinition, "BeanDefinition must not be null");

  if (beanDefinition instanceof AbstractBeanDefinition) {
   try {
    //對(duì)beanDefinition 進(jìn)行校驗(yàn)判斷MethodOverrides不能為空，必須擁有工廠方法
    ((AbstractBeanDefinition) beanDefinition).validate();
   }
   catch (BeanDefinitionValidationException ex) {
    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
      "Validation of bean definition failed", ex);
   }
  }

  BeanDefinition oldBeanDefinition;

  oldBeanDefinition = this.beanDefinitionMap.get(beanName); 
  if (oldBeanDefinition != null) {
    //這個(gè)方法是判斷是否允許出現(xiàn)重名bean，并且是不同的定義bean，是否可以覆蓋前者
   if (!isAllowBeanDefinitionOverriding()) {
    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
      "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
      "': There is already [" + oldBeanDefinition + "] bound.");
   }
   else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
    // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    if (this.logger.isWarnEnabled()) {
     this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
       "' with a framework-generated bean definition: replacing [" +
       oldBeanDefinition + "] with [" + beanDefinition + "]");
    }
   }
   else if (!beanDefinition.equals(oldBeanDefinition)) {
    if (this.logger.isInfoEnabled()) {
     this.logger.info("Overriding bean definition for bean '" + beanName +
       "' with a different definition: replacing [" + oldBeanDefinition +
       "] with [" + beanDefinition + "]");
    }
   }
   else {
    if (this.logger.isDebugEnabled()) {
     this.logger.debug("Overriding bean definition for bean '" + beanName +
       "' with an equivalent definition: replacing [" + oldBeanDefinition +
       "] with [" + beanDefinition + "]");
    }
   }
   this.beanDefinitionMap.put(beanName, beanDefinition);
  }
  else {
   //調(diào)用alreadyCreated.isEmpty()，alreadyCreated Set對(duì)象，保存已經(jīng)創(chuàng)建beanName
   //文檔中表示created，跟這里注冊(cè)應(yīng)該不是同一個(gè)行為，這個(gè)要看到后面才知道什么意思
   if (hasBeanCreationStarted()) {
    synchronized (this.beanDefinitionMap) {//更新數(shù)據(jù)
     this.beanDefinitionMap.put(beanName, beanDefinition);
     List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
     updatedDefinitions.addAll(this.beanDefinitionNames);
     updatedDefinitions.add(beanName);
     this.beanDefinitionNames = updatedDefinitions;
     if (this.manualSingletonNames.contains(beanName)) {
      Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
      updatedSingletons.remove(beanName);
      this.manualSingletonNames = updatedSingletons;
     }
    }
   }
   else { 
    //Spring beanDefinition 容器，一個(gè)Map轉(zhuǎn)載
    this.beanDefinitionMap.put(beanName, beanDefinition);
    //保存beanName，主要用于記錄每個(gè)bean注冊(cè)順序
    this.beanDefinitionNames.add(beanName);
    //刪除單例，注冊(cè)成一個(gè)普通bean
    this.manualSingletonNames.remove(beanName);
   }
   this.frozenBeanDefinitionNames = null;
  }

  if (oldBeanDefinition != null || containsSingleton(beanName)) { 
   //更新Spring容器里beanName
   resetBeanDefinition(beanName);
  }
 }

將beanDefinition注冊(cè)到Spring容器中，并沒(méi)有太多復(fù)雜的邏輯，只是做一些安全性的檢查。

BeanDefinition

一個(gè)BeanDefinition描述了一個(gè)bean的實(shí)例，包括屬性值，構(gòu)造方法參數(shù)值和繼承自它的類的更多信息。BeanDefinition僅僅是一個(gè)最簡(jiǎn)單的接口，主要功能是允許BeanFactoryPostProcessor 例如PropertyPlaceHolderConfigure 能夠檢索并修改屬性值和別的bean的元數(shù)據(jù)（譯注）

Spring 容器beanDefinition主要分為RootBeanDefinition,AnnotatedGenericBeanDefinition這兩種

• RootBeanDefinition     Spring Factory中的特定bean

• AnnotatedGenericBeanDefinition      用戶自定義bean

Spring 啟動(dòng)流程總結(jié)

AnnotationConfigApplicationContext 初始化.png

這些BeanDefinition只是放入到Spirng 容器中，并沒(méi)有進(jìn)行任何初始化對(duì)象的操作，真正的IOC操作都在refresh(),這個(gè)方法有空再進(jìn)行分析。

看完上述內(nèi)容，你們掌握怎么在Spring IOC中利用注解啟動(dòng)的方法了嗎？如果還想學(xué)到更多技能或想了解更多相關(guān)內(nèi)容，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，感謝各位的閱讀！

網(wǎng)頁(yè)題目：怎么在SpringIOC中利用注解啟動(dòng)
分享鏈接：http://chinadenli.net/article18/jdsedp.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供、企業(yè)建站、網(wǎng)站營(yíng)銷、Google、虛擬主機(jī)、移動(dòng)網(wǎng)站建設(shè)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源： 創(chuàng)新互聯(lián)