protected void initXmlApplicationContext(
     AcServiceConfig serviceConfig, boolean autoScan, Resource... configResources) {
   GenericXmlApplicationContext xmlContext = new GenericXmlApplicationContext();
   appContext = xmlContext;
   xmlContext.setParent(prepareParentContext(serviceConfig));
   xmlContext.load(configResources);
   if (autoScan) {
     ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(xmlContext);
     // scan this package from provider hosting
     scanner.scan(this.getClass().getPackage().getName());
   }
   postSetupApplicationContext(appContext, serviceConfig);
   appContext.refresh();
 }
  public static List<Object> scan(ApplicationContext applicationContext, String... basePackages) {
    GenericApplicationContext genericAppContext = new GenericApplicationContext();
    ClassPathBeanDefinitionScanner scanner =
        new ClassPathBeanDefinitionScanner(genericAppContext, false);

    scanner.addIncludeFilter(new AnnotationTypeFilter(RestService.class));
    scanner.scan(basePackages);
    genericAppContext.setParent(applicationContext);
    genericAppContext.refresh();

    List<Object> restResources =
        new ArrayList<>(genericAppContext.getBeansWithAnnotation(RestService.class).values());

    return restResources;
  }
  /**
   * Register a {@link BeanDefinition} for each class specified by {@link #getConfigLocations()}, or
   * scan each specified package for annotated classes. Enables the default set of annotation
   * configuration post processors, such that {@literal @Autowired}, {@literal @Required}, and
   * associated annotations can be used.
   *
   * <p>Configuration class bean definitions are registered with generated bean definition names
   * unless the {@literal value} attribute is provided to the stereotype annotation.
   *
   * @see #getConfigLocations()
   * @see AnnotatedBeanDefinitionReader
   * @see ClassPathBeanDefinitionScanner
   */
  @Override
  protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(beanFactory);
    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (beanNameGenerator != null) {
      reader.setBeanNameGenerator(beanNameGenerator);
      scanner.setBeanNameGenerator(beanNameGenerator);
    }
    if (scopeMetadataResolver != null) {
      reader.setScopeMetadataResolver(scopeMetadataResolver);
      scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
      for (String configLocation : configLocations) {
        try {
          Class<?> clazz = getClassLoader().loadClass(configLocation);
          if (logger.isInfoEnabled()) {
            logger.info("Successfully resolved class for [" + configLocation + "]");
          }
          reader.register(clazz);
        } catch (ClassNotFoundException ex) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Could not load class for config location ["
                    + configLocation
                    + "] - trying package scan. "
                    + ex);
          }
          int count = scanner.scan(configLocation);
          if (logger.isInfoEnabled()) {
            if (count == 0) {
              logger.info(
                  "No annotated classes found for specified class/package ["
                      + configLocation
                      + "]");
            } else {
              logger.info(
                  "Found " + count + " annotated classes in package [" + configLocation + "]");
            }
          }
        }
      }
    }
  }
  private void parseGrailsApplication(
      Element element,
      ParserContext parserContext,
      XmlReaderContext readerContext,
      ClassLoader beanClassLoader,
      String[] basePackages) {

    BeanDefinitionRegistry simpleRegistry = new SimpleBeanDefinitionRegistry();
    ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, simpleRegistry);

    scanner.scan(basePackages);

    BeanDefinitionRegistry targetRegistry = parserContext.getRegistry();
    AbstractBeanDefinition grailsApplicationBean = new GenericBeanDefinition();
    grailsApplicationBean.setBeanClass(DefaultGrailsApplication.class);
    grailsApplicationBean.setInitMethodName("initialise");
    ConstructorArgumentValues constructorArgs =
        grailsApplicationBean.getConstructorArgumentValues();

    Set<Class<?>> classes = new HashSet<Class<?>>();
    for (String beanName : simpleRegistry.getBeanDefinitionNames()) {
      BeanDefinition beanDef = simpleRegistry.getBeanDefinition(beanName);
      try {
        Class<?> entityClass = Class.forName(beanDef.getBeanClassName(), true, beanClassLoader);
        classes.add(entityClass);
        registerDomainBean(
            entityClass, targetRegistry, element.getAttribute(MESSAGE_SOURCE_ATTRIBUTE));
      } catch (ClassNotFoundException e) {
        throw new BeanDefinitionParsingException(
            new Problem(
                "Unable to load class whilst configuring GORM: " + e.getMessage(),
                new Location(readerContext.getResource()),
                null,
                e));
      }
    }

    constructorArgs.addGenericArgumentValue(classes.toArray(new Class[classes.size()]));
    constructorArgs.addGenericArgumentValue(beanClassLoader);
    targetRegistry.registerBeanDefinition(GrailsApplication.APPLICATION_ID, grailsApplicationBean);
  }