Example #1
0
 private void initWildcardDefinitionMap() {
   if (null != appContexts) {
     for (ApplicationContext appContext : appContexts) {
       for (String n : appContext.getBeanDefinitionNames()) {
         if (isWildcardBeanName(n)) {
           AutowireCapableBeanFactory bf = appContext.getAutowireCapableBeanFactory();
           BeanDefinitionRegistry bdr = (BeanDefinitionRegistry) bf;
           BeanDefinition bd = bdr.getBeanDefinition(n);
           String className = bd.getBeanClassName();
           if (null != className) {
             String orig = n;
             if (n.charAt(0) == '*') {
               // old wildcard
               n = "." + n.replaceAll("\\.", "\\.");
             }
             try {
               Matcher matcher = Pattern.compile(n).matcher("");
               List<MatcherHolder> m = wildCardBeanDefinitions.get(className);
               if (m == null) {
                 m = new ArrayList<MatcherHolder>();
                 wildCardBeanDefinitions.put(className, m);
               }
               MatcherHolder holder = new MatcherHolder(orig, matcher);
               m.add(holder);
             } catch (PatternSyntaxException npe) {
               // not a valid patter, we'll ignore
             }
           } else {
             LOG.warn("Wildcars with not class {}", n);
           }
         }
       }
     }
   }
 }
 private String getResourceDescription(String beanName, ListableBeanFactory beanFactory) {
   if (beanFactory instanceof BeanDefinitionRegistry) {
     BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
     return registry.getBeanDefinition(beanName).getResourceDescription();
   }
   return "unknown";
 }
  /**
   * Registers bean definitions for a {@link PluginRegistry} to capture {@link RelProvider}
   * instances. Wraps the registry into a {@link DelegatingRelProvider} bean definition backed by
   * the registry.
   *
   * @param registry
   */
  private static void registerRelProviderPluginRegistryAndDelegate(
      BeanDefinitionRegistry registry) {

    Class<?> defaultRelProviderType =
        EVO_PRESENT ? EvoInflectorRelProvider.class : DefaultRelProvider.class;
    RootBeanDefinition defaultRelProviderBeanDefinition =
        new RootBeanDefinition(defaultRelProviderType);
    registry.registerBeanDefinition("defaultRelProvider", defaultRelProviderBeanDefinition);

    RootBeanDefinition annotationRelProviderBeanDefinition =
        new RootBeanDefinition(AnnotationRelProvider.class);
    registry.registerBeanDefinition("annotationRelProvider", annotationRelProviderBeanDefinition);

    BeanDefinitionBuilder registryFactoryBeanBuilder =
        BeanDefinitionBuilder.rootBeanDefinition(PluginRegistryFactoryBean.class);
    registryFactoryBeanBuilder.addPropertyValue("type", RelProvider.class);
    registryFactoryBeanBuilder.addPropertyValue("exclusions", DelegatingRelProvider.class);

    AbstractBeanDefinition registryBeanDefinition = registryFactoryBeanBuilder.getBeanDefinition();
    registry.registerBeanDefinition("relProviderPluginRegistry", registryBeanDefinition);

    BeanDefinitionBuilder delegateBuilder =
        BeanDefinitionBuilder.rootBeanDefinition(DelegatingRelProvider.class);
    delegateBuilder.addConstructorArgValue(registryBeanDefinition);

    AbstractBeanDefinition beanDefinition = delegateBuilder.getBeanDefinition();
    beanDefinition.setPrimary(true);
    registry.registerBeanDefinition(DELEGATING_REL_PROVIDER_BEAN_NAME, beanDefinition);
  }
  private void registerBeanDefinitionsWithRegistry(BeanDefinitionRegistry registry) {
    for (Object key : beanDefinitions.keySet()) {
      BeanDefinition bd = beanDefinitions.get(key);
      if (LOG.isDebugEnabled()) {
        LOG.debug("[RuntimeConfiguration] Registering bean [" + key + "]");
        if (LOG.isTraceEnabled()) {
          PropertyValue[] pvs = bd.getPropertyValues().getPropertyValues();
          for (PropertyValue pv : pvs) {
            LOG.trace(
                "[RuntimeConfiguration] With property ["
                    + pv.getName()
                    + "] set to ["
                    + pv.getValue()
                    + "]");
          }
        }
      }
      final String beanName = key.toString();
      if (registry.containsBeanDefinition(beanName)) {
        removeBeanDefinition(registry, beanName);
      }

      registry.registerBeanDefinition(beanName, bd);
      registerBeanAliases(registry, beanName);
    }
  }
  @Override
  public void registerBeanDefinitions(AnnotationMetadata meta, BeanDefinitionRegistry registry) {
    Map<String, Object> attrs = meta.getAnnotationAttributes(EnableReactor.class.getName());

    // Create a root Enivronment
    if (!registry.containsBeanDefinition(Environment.class.getName())) {
      BeanDefinitionBuilder envBeanDef =
          BeanDefinitionBuilder.rootBeanDefinition(Environment.class);

      String configReaderBean = (String) attrs.get("configurationReader");
      if (StringUtils.hasText(configReaderBean)) {
        envBeanDef.addConstructorArgReference(configReaderBean);
      } else {
        String profileName = (String) attrs.get("value");
        if (StringUtils.hasText(profileName)) {
          envBeanDef.addConstructorArgValue(new PropertiesConfigurationReader(profileName));
        }
      }
      registry.registerBeanDefinition(Environment.class.getName(), envBeanDef.getBeanDefinition());
    }

    // Create a ConsumerBeanPostProcessor
    if (!registry.containsBeanDefinition(ConsumerBeanPostProcessor.class.getName())) {
      BeanDefinitionBuilder envBeanDef =
          BeanDefinitionBuilder.rootBeanDefinition(ConsumerBeanPostProcessor.class);
      registry.registerBeanDefinition(
          ConsumerBeanPostProcessor.class.getName(), envBeanDef.getBeanDefinition());
    }
  }
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
     throws BeansException {
   Collection<Class<?>> remotingServices = new HashSet<Class<?>>();
   remotingServices.addAll(getIncludeClasses());
   String[] basePackages = getBasePackages();
   if (basePackages != null)
     remotingServices.addAll(ClassScanner.scanAnnotated(basePackages, Remoting.class));
   Collection<Class<?>> excludeRemotingServices = getExcludeClasses();
   for (Class<?> remotingService : remotingServices) {
     if (!remotingService.isInterface() || excludeRemotingServices.contains(remotingService))
       continue;
     String beanName = StringUtils.uncapitalize(remotingService.getSimpleName());
     if (registry.containsBeanDefinition(beanName)) {
       logger.info(
           "Skip bean {} which implemented by {}",
           beanName,
           registry.getBeanDefinition(beanName).getBeanClassName());
       continue;
     }
     RootBeanDefinition beanDefinition = new RootBeanDefinition(HttpInvokerClient.class);
     beanDefinition.setTargetType(remotingService);
     beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_NAME);
     MutablePropertyValues propertyValues = new MutablePropertyValues();
     propertyValues.addPropertyValue("serviceInterface", remotingService.getName());
     beanDefinition.setPropertyValues(propertyValues);
     registry.registerBeanDefinition(beanName, beanDefinition);
     logger.info("Registered bean {} for remoting service", beanName);
   }
 }
  /**
   * Register a {@link WebSocketHandlerMappingFactoryBean} which could also be overridden by the
   * user by simply using {@link org.springframework.web.socket.config.annotation.EnableWebSocket}
   *
   * <p>In addition, checks if the {@code javax.servlet.Servlet} class is present on the classpath.
   * When Spring Integration WebSocket support is used only as a WebSocket client, there is no
   * reason to use and register the Spring WebSocket server components.
   *
   * <p>Note, there is no XML equivalent for the {@link
   * org.springframework.web.socket.config.annotation .EnableWebSocket} in the Spring WebSocket.
   * therefore this registration can be used to process {@link WebSocketConfigurer} implementations
   * without annotation configuration. From other side it can be used to replace {@link
   * org.springframework.web.socket.config.annotation.EnableWebSocket} in the Spring Integration
   * applications when {@link org.springframework.integration.config.EnableIntegration} is in use.
   */
  private void registerEnableWebSocketIfNecessary(BeanDefinitionRegistry registry) {
    if (servletPresent) {
      if (!registry.containsBeanDefinition("defaultSockJsTaskScheduler")) {
        BeanDefinitionBuilder sockJsTaskSchedulerBuilder =
            BeanDefinitionBuilder.genericBeanDefinition(ThreadPoolTaskScheduler.class)
                .addPropertyValue("threadNamePrefix", "SockJS-")
                .addPropertyValue("poolSize", Runtime.getRuntime().availableProcessors())
                .addPropertyValue("removeOnCancelPolicy", true);

        registry.registerBeanDefinition(
            "defaultSockJsTaskScheduler", sockJsTaskSchedulerBuilder.getBeanDefinition());
      }

      if (!registry.containsBeanDefinition(DelegatingWebSocketConfiguration.class.getName())
          && !registry.containsBeanDefinition(WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME)) {
        BeanDefinitionBuilder enableWebSocketBuilder =
            BeanDefinitionBuilder.genericBeanDefinition(WebSocketHandlerMappingFactoryBean.class)
                .setRole(BeanDefinition.ROLE_INFRASTRUCTURE)
                .addConstructorArgReference("defaultSockJsTaskScheduler");

        registry.registerBeanDefinition(
            WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME, enableWebSocketBuilder.getBeanDefinition());
      }
    }
  }
  private void registerBeanConfigsWithRegistry(BeanDefinitionRegistry registry) {
    for (BeanConfiguration bc : beanConfigs.values()) {
      String beanName = bc.getName();
      if (LOG.isDebugEnabled()) {
        LOG.debug("[RuntimeConfiguration] Registering bean [" + beanName + "]");
        if (LOG.isTraceEnabled()) {
          PropertyValue[] pvs = bc.getBeanDefinition().getPropertyValues().getPropertyValues();
          for (PropertyValue pv : pvs) {
            LOG.trace(
                "[RuntimeConfiguration] With property ["
                    + pv.getName()
                    + "] set to ["
                    + pv.getValue()
                    + "]");
          }
        }
      }

      if (registry.containsBeanDefinition(beanName)) {
        removeBeanDefinition(registry, beanName);
      }

      registry.registerBeanDefinition(beanName, bc.getBeanDefinition());
      registerBeanAliases(registry, beanName);
    }
  }
  public BeanDefinition parse(Element element, ParserContext parserContext) {

    final XmlReaderContext readerContext = parserContext.getReaderContext();
    final ClassLoader beanClassLoader =
        readerContext.getBeanClassLoader() != null
            ? readerContext.getBeanClassLoader()
            : Thread.currentThread().getContextClassLoader();

    String[] basePackages =
        StringUtils.commaDelimitedListToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE));

    String dataSourceId = element.getAttribute(DATA_SOURCE_ATTRIBUTE);
    if (!StringUtils.hasText(dataSourceId)) {
      throw new BeanDefinitionParsingException(
          new Problem(
              "Attribute ["
                  + DATA_SOURCE_ATTRIBUTE
                  + "] of tag <gorm:sessionFactory> must be specified!",
              new Location(readerContext.getResource())));
    }

    // Actually scan for bean definitions and register them.
    BeanDefinitionRegistry targetRegistry = parserContext.getRegistry();

    // setup the GrailsApplication instance
    parseGrailsApplication(element, parserContext, readerContext, beanClassLoader, basePackages);

    GenericBeanDefinition postProccessingBeanDef = new GenericBeanDefinition();
    postProccessingBeanDef.setBeanClass(GORMEnhancingBeanPostProcessor.class);

    targetRegistry.registerBeanDefinition("gormEnhancingPostProcessor", postProccessingBeanDef);

    return parseSessionFactory(element, dataSourceId, targetRegistry, parserContext);
  }
  @Override
  public BeanDefinition parse(Element element, ParserContext parserContext) {
    Object source = parserContext.extractSource(element);

    CompositeComponentDefinition compDefinition =
        new CompositeComponentDefinition(element.getTagName(), source);
    parserContext.pushContainingComponent(compDefinition);

    BeanDefinitionRegistry registry = parserContext.getRegistry();

    if (registry.containsBeanDefinition(STAT_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      parserContext
          .getReaderContext()
          .error("Only one DruidStatBeanDefinitionParser may exist within the context.", source);
    } else {
      BeanDefinitionBuilder builder =
          BeanDefinitionBuilder.genericBeanDefinition(STAT_ANNOTATION_PROCESSOR_BEAN_CLASS);
      builder.getRawBeanDefinition().setSource(source);
      registerComponent(parserContext, builder, STAT_ANNOTATION_PROCESSOR_BEAN_NAME);
    }

    if (!registry.containsBeanDefinition(STAT_ANNOTATION_ADVICE_BEAN_NAME)) {
      BeanDefinitionBuilder builder =
          BeanDefinitionBuilder.genericBeanDefinition(STAT_ANNOTATION_ADVICE_BEAN_CLASS);
      builder.getRawBeanDefinition().setSource(source);
      registerComponent(parserContext, builder, STAT_ANNOTATION_ADVICE_BEAN_NAME);
    }

    parserContext.popAndRegisterContainingComponent();

    return null;
  }
  private AbstractBeanDefinition parseSessionFactory(
      Element element,
      String dataSourceId,
      BeanDefinitionRegistry targetRegistry,
      ParserContext parserContext) {
    String sessionFactoryId =
        StringUtils.hasText(element.getAttribute(ID_ATTRIBUTE))
            ? element.getAttribute(ID_ATTRIBUTE)
            : "sessionFactory";
    AbstractBeanDefinition sessionFactoryBean = new GenericBeanDefinition();
    sessionFactoryBean.setBeanClass(ConfigurableLocalSessionFactoryBean.class);

    MutablePropertyValues propertyValues = sessionFactoryBean.getPropertyValues();
    final RuntimeBeanReference dataSourceRef = new RuntimeBeanReference(dataSourceId);
    propertyValues.addPropertyValue("dataSource", dataSourceRef);

    Class<?> configClass = lookupConfigClass(element, parserContext);
    propertyValues.addPropertyValue("configClass", configClass);

    final String configLocation = element.getAttribute(CONFIG_LOCATION_ATTRIBUTE);
    if (StringUtils.hasText(configLocation)) {
      propertyValues.addPropertyValue("configLocation", configLocation);
    }

    propertyValues.addPropertyValue(
        GrailsApplication.APPLICATION_ID,
        new RuntimeBeanReference(GrailsApplication.APPLICATION_ID));

    targetRegistry.registerBeanDefinition(sessionFactoryId, sessionFactoryBean);

    final String lobHandlerRef = element.getAttribute(LOB_HANDLER_ATTRIBUTE);
    if (StringUtils.hasText(lobHandlerRef)) {
      propertyValues.addPropertyValue("lobHandler", new RuntimeBeanReference(lobHandlerRef));
    } else {
      GenericBeanDefinition lobHandler = new GenericBeanDefinition();
      lobHandler.setBeanClass(SpringLobHandlerDetectorFactoryBean.class);
      lobHandler.getPropertyValues().addPropertyValue("pooledConnection", true);
      lobHandler.getPropertyValues().addPropertyValue("dataSource", dataSourceRef);
      propertyValues.addPropertyValue("lobHandler", lobHandler);
    }

    String transactionManagerRef = element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE);
    if (StringUtils.hasText(transactionManagerRef)) {
      targetRegistry.registerAlias(transactionManagerRef, "transactionManager");
    } else {
      GenericBeanDefinition transactionManagerBean = new GenericBeanDefinition();
      transactionManagerBean.setBeanClass(GrailsHibernateTransactionManager.class);
      transactionManagerBean
          .getPropertyValues()
          .addPropertyValue("sessionFactory", new RuntimeBeanReference(sessionFactoryId));

      targetRegistry.registerBeanDefinition("transactionManager", transactionManagerBean);
    }

    parserContext.getDelegate().parsePropertyElements(element, sessionFactoryBean);
    return sessionFactoryBean;
  }
  /**
   * Registers the given {@link AbstractBeanDefinition} with the given registry with the given bean
   * name unless the registry already contains a bean with that name.
   *
   * @param bean must not be {@literal null}.
   * @param registry must not be {@literal null}.
   * @param beanName must not be {@literal null} or empty.
   * @param source must not be {@literal null}.
   */
  public static void registerIfNotAlreadyRegistered(
      AbstractBeanDefinition bean,
      BeanDefinitionRegistry registry,
      String beanName,
      Object source) {

    if (registry.containsBeanDefinition(beanName)) {
      return;
    }

    bean.setSource(source);
    registry.registerBeanDefinition(beanName, bean);
  }
 @Override
 public synchronized <T> T registerAndGetBean(
     Class<? extends T> type, final String id, final Scope scope) {
   if (contains(id)) return getBean(id);
   final AutowireCapableBeanFactory factory = getContext().getAutowireCapableBeanFactory();
   final BeanDefinitionRegistry registry = (BeanDefinitionRegistry) factory;
   final GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
   beanDefinition.setBeanClass(type);
   if (scope != null) beanDefinition.setScope(scope.getType());
   beanDefinition.setAutowireCandidate(true);
   registry.registerBeanDefinition(id, beanDefinition);
   factory.autowireBeanProperties(this, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
   return getBean(id);
 }
 @Override
 protected void createOperationsBean(BeanDefinitionRegistry registry) {
   String beanName = "s3ResourceTemplate";
   BeanDefinitionBuilder builder =
       BeanDefinitionBuilder.genericBeanDefinition(S3ResourceTemplate.class);
   registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
 }
 private void registerUnrefreshedBeansWithRegistry(BeanDefinitionRegistry registry) {
   if (context != null) {
     for (String beanName : context.getBeanDefinitionNames()) {
       registry.registerBeanDefinition(beanName, context.getBeanDefinition(beanName));
     }
   }
 }
 private void registerBeanAliases(BeanDefinitionRegistry beanDefinitionRegistry, String beanName) {
   List<String> beanAliases = aliases.get(beanName);
   if (beanAliases != null && !beanAliases.isEmpty()) {
     for (String alias : beanAliases) {
       beanDefinitionRegistry.registerAlias(beanName, alias);
     }
   }
 }
 private void process(
     BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory) {
   BeanDefinitionHolder holder = getDataSourceBeanDefinition(beanFactory);
   if (holder != null) {
     logger.info(
         "Replacing '" + holder.getBeanName() + "' DataSource bean with embedded version");
     registry.registerBeanDefinition(holder.getBeanName(), createEmbeddedBeanDefinition());
   }
 }
 /**
  * Register the specified entity scan packages with the system.
  *
  * @param registry the source registry
  * @param packageNames the package names to register
  */
 public static void register(BeanDefinitionRegistry registry, Collection<String> packageNames) {
   Assert.notNull(registry, "Registry must not be null");
   Assert.notNull(packageNames, "PackageNames must not be null");
   if (registry.containsBeanDefinition(BEAN)) {
     BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
     ConstructorArgumentValues constructorArguments =
         beanDefinition.getConstructorArgumentValues();
     constructorArguments.addIndexedArgumentValue(
         0, addPackageNames(constructorArguments, packageNames));
   } else {
     GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
     beanDefinition.setBeanClass(EntityScanPackages.class);
     beanDefinition
         .getConstructorArgumentValues()
         .addIndexedArgumentValue(0, packageNames.toArray(new String[packageNames.size()]));
     beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
     registry.registerBeanDefinition(BEAN, beanDefinition);
   }
 }
  /**
   * Sets the given source on the given {@link AbstractBeanDefinition} and registers it inside the
   * given {@link BeanDefinitionRegistry}. For {@link BeanDefinition}s to be registerd
   * once-and-only-once for all configuration elements (annotation or XML), prefer calling {@link
   * #registerIfNotAlreadyRegistered(AbstractBeanDefinition, BeanDefinitionRegistry, String,
   * Object)} with a dedicated bean name to avoid the bead definition being registered multiple
   * times. *
   *
   * @param registry must not be {@literal null}.
   * @param bean must not be {@literal null}.
   * @param source must not be {@literal null}.
   * @return the bean name generated for the given {@link BeanDefinition}
   */
  public static String registerWithSourceAndGeneratedBeanName(
      BeanDefinitionRegistry registry, AbstractBeanDefinition bean, Object source) {

    bean.setSource(source);

    String beanName = generateBeanName(bean, registry);
    registry.registerBeanDefinition(beanName, bean);

    return beanName;
  }
  @Override
  protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
    for (String basePackage : basePackages) {
      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
      for (BeanDefinition candidate : candidates) {
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
        candidate.setScope(scopeMetadata.getScopeName());
        String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
        if (candidate instanceof AbstractBeanDefinition) {
          postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
        }
        if (candidate instanceof AnnotatedBeanDefinition) {
          processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
        }

        ScannedGenericBeanDefinition bd = (ScannedGenericBeanDefinition) candidate; // 通用bean扫描
        bd.setBeanClassName(HessianServiceExporter.class.getName()); // 设置bean名称
        bd.setBeanClass(HessianServiceExporter.class); // 设置bean类
        bd.getPropertyValues().add("service", registry.getBeanDefinition(beanName)); // 设置属性 service
        String[] interfaces = bd.getMetadata().getInterfaceNames(); // 获得元数据、接口名称

        if (interfaces == null || interfaces.length == 0) continue;
        Class interf = null;
        try {
          interf = Class.forName(interfaces[0]); // 获得接口
        } catch (ClassNotFoundException e) {
          continue;
        }
        bd.getPropertyValues().add("serviceInterface", interf); // 设置属性 serviceInterface
        candidate = bd;
        BeanDefinitionHolder definitionHolder =
            new BeanDefinitionHolder(candidate, "/" + beanName); // 新bean定义持有
        definitionHolder =
            applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 应用范围代理模式
        beanDefinitions.add(definitionHolder); // 将bean定义持有放入bean定义持有set中
        registerBeanDefinition(definitionHolder, this.registry); // 注册bean定义
      }
    }

    if (beanDefinitions.isEmpty()) {
      System.out.println("not service be scaned");
    } else {
      for (BeanDefinitionHolder holder : beanDefinitions) {
        AnnotatedBeanDefinition definition =
            (AnnotatedBeanDefinition) holder.getBeanDefinition(); // 注释的bean定义
        System.out.println("service:" + holder.getBeanName()); // 注释的bean定义名称
        System.out.println(
            "service:" + definition.getMetadata().getAnnotationTypes()); // 注释的bean定义类型
      }
    }

    return beanDefinitions;
  }
 private void processRegularClass(BeanDefinitionRegistry registry, Class implementation) {
   LOG.debug(
       String.format(
           "Registering bean definition for implementation class %s",
           implementation.getCanonicalName()));
   String beanName = implementation.getCanonicalName();
   GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
   beanDefinition.setBeanClass(implementation);
   beanDefinition.setAutowireMode(AUTOWIRE_BY_TYPE);
   registry.registerBeanDefinition(beanName, beanDefinition);
 }
  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);
  }
 @Override
 public void registerBeanDefinitions(
     AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   if (this.beanFactory != null
       && this.beanFactory
               .getBeansOfType(EmbeddedServletContainerCustomizerBeanPostProcessor.class)
               .size()
           == 0) {
     BeanDefinition beanDefinition =
         new RootBeanDefinition(EmbeddedServletContainerCustomizerBeanPostProcessor.class);
     registry.registerBeanDefinition(
         "embeddedServletContainerCustomizerBeanPostProcessor", beanDefinition);
   }
 }
 private void processRepositoryInterface(
     BeanDefinitionRegistry registry, Class repositoryInterface) {
   LOG.debug(
       String.format(
           "Registering bean definition for repository interface %s",
           repositoryInterface.getCanonicalName()));
   String beanName = Introspector.decapitalize(repositoryInterface.getSimpleName());
   GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
   beanDefinition.setBeanClass(JpaRepositoryFactoryBean.class);
   MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
   mutablePropertyValues.add("repositoryInterface", repositoryInterface);
   beanDefinition.setPropertyValues(mutablePropertyValues);
   registry.registerBeanDefinition(beanName, beanDefinition);
 }
Example #25
0
  /**
   * 增加自动跟踪的auto tracer bean definition
   *
   * @param beanFactory
   */
  public static void addTracerBeanDefinition(final BeanDefinitionRegistry beanFactory) {
    AbstractBeanDefinition pointcut = new GenericBeanDefinition();
    pointcut.setBeanClassName(
        org.jtester.module.tracer.spring.TracerMethodRegexPointcut.class.getName());
    pointcut.setScope("singleton");
    pointcut.setAutowireCandidate(false);

    pointcut.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);

    beanFactory.registerBeanDefinition("jtester-internal-methodname-pointcut", pointcut);

    AbstractBeanDefinition advice = new GenericBeanDefinition();
    advice.setBeanClassName(org.jtester.module.tracer.spring.SpringBeanTracer.class.getName());
    advice.setScope("singleton");
    advice.setAutowireCandidate(false);

    advice.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);

    beanFactory.registerBeanDefinition("jtester-internal-springbeantracer", advice);

    AbstractBeanDefinition advisor = new GenericBeanDefinition();
    advisor.setBeanClassName(
        org.springframework.aop.support.DefaultPointcutAdvisor.class.getName());
    advisor.setScope("singleton");
    advisor.setAutowireCandidate(false);

    advisor.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);
    advisor
        .getPropertyValues()
        .addPropertyValue(
            "pointcut", new RuntimeBeanReference("jtester-internal-methodname-pointcut"));
    advisor
        .getPropertyValues()
        .addPropertyValue("advice", new RuntimeBeanReference("jtester-internal-springbeantracer"));

    beanFactory.registerBeanDefinition("jtester-internal-beantracer-advisor", advisor);
  }
 @Override
 public Object buildBean(String beanName, Map<String, Object> extraContext) throws Exception {
   LOG.debug("Building bean for name {}", beanName);
   if (!skipBeanNames.contains(beanName)) {
     ApplicationContext anAppContext = getApplicationContext(extraContext);
     try {
       LOG.debug(
           "Trying the application context... appContext = {},\n bean name = {}",
           anAppContext,
           beanName);
       return anAppContext.getBean(beanName);
     } catch (NoSuchBeanDefinitionException e) {
       LOG.debug(
           "Did not find bean definition for bean named {}, creating a new one...", beanName);
       if (autoWiringFactory instanceof BeanDefinitionRegistry) {
         try {
           Class clazz = Class.forName(beanName);
           BeanDefinitionRegistry registry = (BeanDefinitionRegistry) autoWiringFactory;
           RootBeanDefinition def = new RootBeanDefinition(clazz, autowireStrategy, true);
           def.setScope(BeanDefinition.SCOPE_SINGLETON);
           LOG.debug("Registering a new bean definition for class {}", beanName);
           registry.registerBeanDefinition(beanName, def);
           try {
             return anAppContext.getBean(beanName);
           } catch (NoSuchBeanDefinitionException e2) {
             LOG.warn("Could not register new bean definition for bean {}", beanName);
             skipBeanNames.add(beanName);
           }
         } catch (ClassNotFoundException e1) {
           skipBeanNames.add(beanName);
         }
       }
     }
   }
   LOG.debug("Returning autowired instance created by default ObjectFactory");
   return autoWireBean(super.buildBean(beanName, extraContext), autoWiringFactory);
 }
  private void registerDomainBean(
      final Class<?> entityClass, BeanDefinitionRegistry targetRegistry, String messageSourceRef) {
    GenericBeanDefinition beanDef = new GenericBeanDefinition();
    beanDef.setBeanClass(entityClass);
    beanDef.setScope("prototype");

    RootBeanDefinition domainDef = new RootBeanDefinition(MethodInvokingFactoryBean.class);

    domainDef
        .getPropertyValues()
        .addPropertyValue(
            "targetObject", new RuntimeBeanReference(GrailsApplication.APPLICATION_ID));
    domainDef.getPropertyValues().addPropertyValue("targetMethod", "getArtefact");
    domainDef
        .getPropertyValues()
        .addPropertyValue(
            "arguments", Arrays.asList(DomainClassArtefactHandler.TYPE, entityClass.getName()));

    final String domainRef = entityClass.getName() + "Domain";
    if (StringUtils.hasText(messageSourceRef)) {
      GenericBeanDefinition validatorDef = new GenericBeanDefinition();
      validatorDef.setBeanClass(HibernateDomainClassValidator.class);
      validatorDef
          .getPropertyValues()
          .addPropertyValue("messageSource", new RuntimeBeanReference(messageSourceRef));
      validatorDef
          .getPropertyValues()
          .addPropertyValue("domainClass", new RuntimeBeanReference(domainRef));
      validatorDef
          .getPropertyValues()
          .addPropertyValue("sessionFactory", new RuntimeBeanReference("sessionFactory"));
      targetRegistry.registerBeanDefinition(entityClass.getName() + "Validator", validatorDef);
    }

    targetRegistry.registerBeanDefinition(entityClass.getName(), beanDef);
    targetRegistry.registerBeanDefinition(domainRef, domainDef);
  }
  /**
   * Returns the bean name of a {@link MappingContext} to be wired. Will inspect the namespace
   * attribute first and if no config is found in that place it will try to lookup the default one.
   * Will return {@literal null} if neither one is available.
   *
   * @param config
   * @param registry
   * @return
   */
  private String getMappingContextReference(
      MongoRepositoryConfiguration config, BeanDefinitionRegistry registry) {

    String contextRef = config.getMappingContextRef();

    if (contextRef != null) {
      return contextRef;
    }

    try {
      registry.getBeanDefinition(MAPPING_CONTEXT_DEFAULT);
      return MAPPING_CONTEXT_DEFAULT;
    } catch (NoSuchBeanDefinitionException e) {
      return null;
    }
  }
 private void testBeanDefinitions(BeanDefinitionRegistry registry) {
   assertEquals(24, registry.getBeanDefinitionCount());
   assertEquals(24, registry.getBeanDefinitionNames().length);
   assertTrue(Arrays.asList(registry.getBeanDefinitionNames()).contains("rod"));
   assertTrue(Arrays.asList(registry.getBeanDefinitionNames()).contains("aliased"));
   assertTrue(registry.containsBeanDefinition("rod"));
   assertTrue(registry.containsBeanDefinition("aliased"));
   assertEquals(TestBean.class.getName(), registry.getBeanDefinition("rod").getBeanClassName());
   assertEquals(
       TestBean.class.getName(), registry.getBeanDefinition("aliased").getBeanClassName());
   assertTrue(registry.isAlias("youralias"));
   assertEquals(2, registry.getAliases("aliased").length);
   assertEquals("myalias", registry.getAliases("aliased")[0]);
   assertEquals("youralias", registry.getAliases("aliased")[1]);
 }
  /**
   * Returns whether the given {@link BeanDefinitionRegistry} already contains a bean of the given
   * type assuming the bean name has been autogenerated.
   *
   * @param type
   * @param registry
   * @return
   */
  public static boolean hasBean(Class<?> type, BeanDefinitionRegistry registry) {

    String name = String.format("%s%s0", type.getName(), GENERATED_BEAN_NAME_SEPARATOR);
    return registry.containsBeanDefinition(name);
  }