Java Code Examples for org.springframework.core.annotation.AnnotationAwareOrderComparator

The following examples show how to use org.springframework.core.annotation.AnnotationAwareOrderComparator. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
public void init()
{
    List<FeatureIndexingSupport> fsp = new ArrayList<>();

    if (indexingSupportsProxy != null) {
        fsp.addAll(indexingSupportsProxy);
        AnnotationAwareOrderComparator.sort(fsp);
    
        for (FeatureIndexingSupport fs : fsp) {
            log.info("Found indexing support: {}",
                    ClassUtils.getAbbreviatedName(fs.getClass(), 20));
        }
    }
    
    indexingSupports = Collections.unmodifiableList(fsp);
}
 
Example 2
Source Project: spring-analysis-note   Source File: DispatcherHandler.java    License: MIT License 6 votes vote down vote up
protected void initStrategies(ApplicationContext context) {
	Map<String, HandlerMapping> mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
			context, HandlerMapping.class, true, false);

	ArrayList<HandlerMapping> mappings = new ArrayList<>(mappingBeans.values());
	AnnotationAwareOrderComparator.sort(mappings);
	this.handlerMappings = Collections.unmodifiableList(mappings);

	Map<String, HandlerAdapter> adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
			context, HandlerAdapter.class, true, false);

	this.handlerAdapters = new ArrayList<>(adapterBeans.values());
	AnnotationAwareOrderComparator.sort(this.handlerAdapters);

	Map<String, HandlerResultHandler> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
			context, HandlerResultHandler.class, true, false);

	this.resultHandlers = new ArrayList<>(beans.values());
	AnnotationAwareOrderComparator.sort(this.resultHandlers);
}
 
Example 3
@Override
protected void initServletContext(ServletContext servletContext) {
	Collection<ViewResolver> matchingBeans =
			BeanFactoryUtils.beansOfTypeIncludingAncestors(obtainApplicationContext(), ViewResolver.class).values();
	if (this.viewResolvers == null) {
		this.viewResolvers = new ArrayList<>(matchingBeans.size());
		for (ViewResolver viewResolver : matchingBeans) {
			if (this != viewResolver) {
				this.viewResolvers.add(viewResolver);
			}
		}
	}
	else {
		for (int i = 0; i < this.viewResolvers.size(); i++) {
			ViewResolver vr = this.viewResolvers.get(i);
			if (matchingBeans.contains(vr)) {
				continue;
			}
			String name = vr.getClass().getName() + i;
			obtainApplicationContext().getAutowireCapableBeanFactory().initializeBean(vr, name);
		}

	}
	AnnotationAwareOrderComparator.sort(this.viewResolvers);
	this.cnmFactoryBean.setServletContext(servletContext);
}
 
Example 4
Source Project: webanno   Source File: ExtensionPoint_ImplBase.java    License: Apache License 2.0 6 votes vote down vote up
public void init()
{
    List<E> extensions = new ArrayList<>();

    if (extensionsListProxy != null) {
        extensions.addAll(extensionsListProxy);
        AnnotationAwareOrderComparator.sort(extensions);
    
        for (E fs : extensions) {
            log.info("Found {} extension: {}", getClass().getSimpleName(),
                    getAbbreviatedName(fs.getClass(), 20));
        }
    }
    
    extensionsList = Collections.unmodifiableList(extensions);
}
 
Example 5
/**
 * Create {@link PropertySource}s given {@link Environment} from the property
 * configuration.
 * @param environment must not be {@literal null}.
 * @return a {@link List} of ordered {@link PropertySource}s.
 */
protected List<PropertySource<?>> doCreatePropertySources(Environment environment) {

	Collection<SecretBackendMetadata> secretBackends = this.propertySourceLocatorConfiguration
			.getSecretBackends();
	List<SecretBackendMetadata> sorted = new ArrayList<>(secretBackends);
	List<PropertySource<?>> propertySources = new ArrayList<>();

	AnnotationAwareOrderComparator.sort(sorted);

	propertySources.addAll(doCreateKeyValuePropertySources(environment));

	for (SecretBackendMetadata backendAccessor : sorted) {

		PropertySource<?> vaultPropertySource = createVaultPropertySource(
				backendAccessor);
		propertySources.add(vaultPropertySource);
	}

	return propertySources;
}
 
Example 6
@Bean
@ConditionalOnMissingBean(JwtAccessTokenConverter.class)
public JwtAccessTokenConverter jwtTokenEnhancer() {
	JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
	String keyValue = this.resource.getJwt().getKeyValue();
	if (!StringUtils.hasText(keyValue)) {
		keyValue = getKeyFromServer();
	}
	if (StringUtils.hasText(keyValue) && !keyValue.startsWith("-----BEGIN")) {
		converter.setSigningKey(keyValue);
	}
	if (keyValue != null) {
		converter.setVerifierKey(keyValue);
	}
	if (!CollectionUtils.isEmpty(this.configurers)) {
		AnnotationAwareOrderComparator.sort(this.configurers);
		for (JwtAccessTokenConverterConfigurer configurer : this.configurers) {
			configurer.configure(converter);
		}
	}
	return converter;
}
 
Example 7
Source Project: lams   Source File: ContextLoader.java    License: GNU General Public License v2.0 6 votes vote down vote up
/**
 * Customize the {@link ConfigurableWebApplicationContext} created by this
 * ContextLoader after config locations have been supplied to the context
 * but before the context is <em>refreshed</em>.
 * <p>The default implementation {@linkplain #determineContextInitializerClasses(ServletContext)
 * determines} what (if any) context initializer classes have been specified through
 * {@linkplain #CONTEXT_INITIALIZER_CLASSES_PARAM context init parameters} and
 * {@linkplain ApplicationContextInitializer#initialize invokes each} with the
 * given web application context.
 * <p>Any {@code ApplicationContextInitializers} implementing
 * {@link org.springframework.core.Ordered Ordered} or marked with @{@link
 * org.springframework.core.annotation.Order Order} will be sorted appropriately.
 * @param sc the current servlet context
 * @param wac the newly created application context
 * @see #CONTEXT_INITIALIZER_CLASSES_PARAM
 * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)
 */
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
	List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
			determineContextInitializerClasses(sc);

	for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
		Class<?> initializerContextClass =
				GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
		if (initializerContextClass != null && !initializerContextClass.isInstance(wac)) {
			throw new ApplicationContextException(String.format(
					"Could not apply context initializer [%s] since its generic parameter [%s] " +
					"is not assignable from the type of application context used by this " +
					"context loader: [%s]", initializerClass.getName(), initializerContextClass.getName(),
					wac.getClass().getName()));
		}
		this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass));
	}

	AnnotationAwareOrderComparator.sort(this.contextInitializers);
	for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
		initializer.initialize(wac);
	}
}
 
Example 8
Source Project: spring-analysis-note   Source File: BeanFactoryGenericsTests.java    License: MIT License 6 votes vote down vote up
@Test
public void testGenericMatchingWithUnresolvedOrderedStream() {
	DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
	bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
	bf.setAutowireCandidateResolver(new GenericTypeAwareAutowireCandidateResolver());

	RootBeanDefinition bd1 = new RootBeanDefinition(NumberStoreFactory.class);
	bd1.setFactoryMethodName("newDoubleStore");
	bf.registerBeanDefinition("store1", bd1);
	RootBeanDefinition bd2 = new RootBeanDefinition(NumberStoreFactory.class);
	bd2.setFactoryMethodName("newFloatStore");
	bf.registerBeanDefinition("store2", bd2);

	ObjectProvider<NumberStore<?>> numberStoreProvider = bf.getBeanProvider(ResolvableType.forClass(NumberStore.class));
	List<NumberStore<?>> resolved = numberStoreProvider.orderedStream().collect(Collectors.toList());
	assertEquals(2, resolved.size());
	assertSame(bf.getBean("store2"), resolved.get(0));
	assertSame(bf.getBean("store1"), resolved.get(1));
}
 
Example 9
@Test
public void testAutowireBeanByTypeWithIdenticalPriorityCandidates() {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
	RootBeanDefinition bd = new RootBeanDefinition(HighPriorityTestBean.class);
	RootBeanDefinition bd2 = new RootBeanDefinition(HighPriorityTestBean.class);
	lbf.registerBeanDefinition("test", bd);
	lbf.registerBeanDefinition("spouse", bd2);

	try {
		lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
		fail("Should have thrown UnsatisfiedDependencyException");
	}
	catch (UnsatisfiedDependencyException ex) {
		// expected
		assertNotNull("Exception should have cause", ex.getCause());
		assertEquals("Wrong cause type", NoUniqueBeanDefinitionException.class, ex.getCause().getClass());
		assertTrue(ex.getMessage().contains("5"));  // conflicting priority
	}
}
 
Example 10
void init()
{
    List<ExternalSearchProviderFactory> exts = new ArrayList<>();

    if (providersProxy != null) {
        exts.addAll(providersProxy);
        AnnotationAwareOrderComparator.sort(exts);

        for (ExternalSearchProviderFactory fs : exts) {
            log.info("Found external search provider: {}",
                    ClassUtils.getAbbreviatedName(fs.getClass(), 20));
        }
    }

    providers = Collections.unmodifiableList(exts);
}
 
Example 11
Source Project: inception   Source File: PhysicalIndexRegistryImpl.java    License: Apache License 2.0 6 votes vote down vote up
void init()
{
    List<PhysicalIndexFactory> exts = new ArrayList<>();

    if (extensionsProxy != null) {
        exts.addAll(extensionsProxy);
        AnnotationAwareOrderComparator.sort(exts);
    
        for (PhysicalIndexFactory fs : exts) {
            log.info("Found index extension: {}",
                    ClassUtils.getAbbreviatedName(fs.getClass(), 20));
        }
    }
    
    extensions = Collections.unmodifiableList(exts);
}
 
Example 12
Source Project: webanno   Source File: LayerSupportRegistryImpl.java    License: Apache License 2.0 6 votes vote down vote up
public void init()
{
    List<LayerSupport> lsp = new ArrayList<>();

    if (layerSupportsProxy != null) {
        lsp.addAll(layerSupportsProxy);
        AnnotationAwareOrderComparator.sort(lsp);
    
        for (LayerSupport<?, ?> fs : lsp) {
            log.info("Found layer support: {}",
                    ClassUtils.getAbbreviatedName(fs.getClass(), 20));
            fs.setLayerSupportRegistry(this);
        }
    }
    
    layerSupports = Collections.unmodifiableList(lsp);
}
 
Example 13
@Test
public void testConstructorResourceInjectionWithMultipleOrderedCandidates() {
	DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
	bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
	AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
	bpp.setBeanFactory(bf);
	bf.addBeanPostProcessor(bpp);
	bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(ConstructorsResourceInjectionBean.class));
	TestBean tb = new TestBean();
	bf.registerSingleton("testBean", tb);
	FixedOrder2NestedTestBean ntb1 = new FixedOrder2NestedTestBean();
	bf.registerSingleton("nestedTestBean1", ntb1);
	FixedOrder1NestedTestBean ntb2 = new FixedOrder1NestedTestBean();
	bf.registerSingleton("nestedTestBean2", ntb2);

	ConstructorsResourceInjectionBean bean = (ConstructorsResourceInjectionBean) bf.getBean("annotatedBean");
	assertNull(bean.getTestBean3());
	assertSame(tb, bean.getTestBean4());
	assertEquals(2, bean.getNestedTestBeans().length);
	assertSame(ntb2, bean.getNestedTestBeans()[0]);
	assertSame(ntb1, bean.getNestedTestBeans()[1]);
	bf.destroySingletons();
}
 
Example 14
Source Project: java-technology-stack   Source File: SpringFactoriesLoader.java    License: MIT License 6 votes vote down vote up
/**
 * Load and instantiate the factory implementations of the given type from
 * {@value #FACTORIES_RESOURCE_LOCATION}, using the given class loader.
 * <p>The returned factories are sorted through {@link AnnotationAwareOrderComparator}.
 * <p>If a custom instantiation strategy is required, use {@link #loadFactoryNames}
 * to obtain all registered factory names.
 * @param factoryClass the interface or abstract class representing the factory
 * @param classLoader the ClassLoader to use for loading (can be {@code null} to use the default)
 * @throws IllegalArgumentException if any factory implementation class cannot
 * be loaded or if an error occurs while instantiating any factory
 * @see #loadFactoryNames
 */
public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {
	Assert.notNull(factoryClass, "'factoryClass' must not be null");
	ClassLoader classLoaderToUse = classLoader;
	if (classLoaderToUse == null) {
		classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
	}
	List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
	if (logger.isTraceEnabled()) {
		logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
	}
	List<T> result = new ArrayList<>(factoryNames.size());
	for (String factoryName : factoryNames) {
		result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
	}
	AnnotationAwareOrderComparator.sort(result);
	return result;
}
 
Example 15
/**
 * Return an unmodifiable snapshot list of all registered synchronizations
 * for the current thread.
 * @return unmodifiable List of TransactionSynchronization instances
 * @throws IllegalStateException if synchronization is not active
 * @see TransactionSynchronization
 */
public static List<TransactionSynchronization> getSynchronizations() throws IllegalStateException {
	Set<TransactionSynchronization> synchs = synchronizations.get();
	if (synchs == null) {
		throw new IllegalStateException("Transaction synchronization is not active");
	}
	// Return unmodifiable snapshot, to avoid ConcurrentModificationExceptions
	// while iterating and invoking synchronization callbacks that in turn
	// might register further synchronizations.
	if (synchs.isEmpty()) {
		return Collections.emptyList();
	}
	else {
		// Sort lazily here, not in registerSynchronization.
		List<TransactionSynchronization> sortedSynchs = new ArrayList<>(synchs);
		AnnotationAwareOrderComparator.sort(sortedSynchs);
		return Collections.unmodifiableList(sortedSynchs);
	}
}
 
Example 16
@Override
protected void initServletContext(ServletContext servletContext) {
	Collection<ViewResolver> matchingBeans =
			BeanFactoryUtils.beansOfTypeIncludingAncestors(obtainApplicationContext(), ViewResolver.class).values();
	if (this.viewResolvers == null) {
		this.viewResolvers = new ArrayList<>(matchingBeans.size());
		for (ViewResolver viewResolver : matchingBeans) {
			if (this != viewResolver) {
				this.viewResolvers.add(viewResolver);
			}
		}
	}
	else {
		for (int i = 0; i < this.viewResolvers.size(); i++) {
			ViewResolver vr = this.viewResolvers.get(i);
			if (matchingBeans.contains(vr)) {
				continue;
			}
			String name = vr.getClass().getName() + i;
			obtainApplicationContext().getAutowireCapableBeanFactory().initializeBean(vr, name);
		}

	}
	AnnotationAwareOrderComparator.sort(this.viewResolvers);
	this.cnmFactoryBean.setServletContext(servletContext);
}
 
Example 17
Source Project: webanno   Source File: RelationAdapter.java    License: Apache License 2.0 6 votes vote down vote up
public RelationAdapter(LayerSupportRegistry aLayerSupportRegistry,
        FeatureSupportRegistry aFeatureSupportRegistry,
        ApplicationEventPublisher aEventPublisher, AnnotationLayer aLayer,
        String aTargetFeatureName, String aSourceFeatureName,
        Supplier<Collection<AnnotationFeature>> aFeatures,
        List<RelationLayerBehavior> aBehaviors)
{
    super(aLayerSupportRegistry, aFeatureSupportRegistry, aEventPublisher, aLayer, aFeatures);
    
    if (aBehaviors == null) {
        behaviors = emptyList();
    }
    else {
        List<RelationLayerBehavior> temp = new ArrayList<>(aBehaviors);
        AnnotationAwareOrderComparator.sort(temp);
        behaviors = temp;
    }
    
    sourceFeatureName = aSourceFeatureName;
    targetFeatureName = aTargetFeatureName;
}
 
Example 18
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	// Use names and ensure unique to protect against duplicates
	List<String> names = new ArrayList<>(SpringFactoriesLoader
			.loadFactoryNames(BootstrapConfiguration.class, classLoader));
	names.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(
			this.environment.getProperty("spring.cloud.bootstrap.sources", ""))));

	List<OrderedAnnotatedElement> elements = new ArrayList<>();
	for (String name : names) {
		try {
			elements.add(
					new OrderedAnnotatedElement(this.metadataReaderFactory, name));
		}
		catch (IOException e) {
			continue;
		}
	}
	AnnotationAwareOrderComparator.sort(elements);

	String[] classNames = elements.stream().map(e -> e.name).toArray(String[]::new);

	return classNames;
}
 
Example 19
Source Project: inception   Source File: StatementColoringRegistryImpl.java    License: Apache License 2.0 6 votes vote down vote up
public void init()
{
    List<StatementColoringStrategy> fsp = new ArrayList<>();

    if (statementColoringStrategiesProxy != null) {
        fsp.addAll(statementColoringStrategiesProxy);
        AnnotationAwareOrderComparator.sort(fsp);

        for (StatementColoringStrategy fs : fsp) {
            log.info("Found value type support: {}",
                ClassUtils.getAbbreviatedName(fs.getClass(), 20));
        }
    }

    statementColoringStrategies = Collections.unmodifiableList(fsp);
}
 
Example 20
Source Project: spring4-understanding   Source File: ContextLoader.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Customize the {@link ConfigurableWebApplicationContext} created by this
 * ContextLoader after config locations have been supplied to the context
 * but before the context is <em>refreshed</em>.
 * <p>The default implementation {@linkplain #determineContextInitializerClasses(ServletContext)
 * determines} what (if any) context initializer classes have been specified through
 * {@linkplain #CONTEXT_INITIALIZER_CLASSES_PARAM context init parameters} and
 * {@linkplain ApplicationContextInitializer#initialize invokes each} with the
 * given web application context.
 * <p>Any {@code ApplicationContextInitializers} implementing
 * {@link org.springframework.core.Ordered Ordered} or marked with @{@link
 * org.springframework.core.annotation.Order Order} will be sorted appropriately.
 * @param sc the current servlet context
 * @param wac the newly created application context
 * @see #CONTEXT_INITIALIZER_CLASSES_PARAM
 * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)
 */
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
	List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
			determineContextInitializerClasses(sc);

	for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
		Class<?> initializerContextClass =
				GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
		if (initializerContextClass != null) {
			Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(
					"Could not add context initializer [%s] since its generic parameter [%s] " +
					"is not assignable from the type of application context used by this " +
					"context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(),
					wac.getClass().getName()));
		}
		this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass));
	}

	AnnotationAwareOrderComparator.sort(this.contextInitializers);
	for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
		initializer.initialize(wac);
	}
}
 
Example 21
@Test
public void testMapInjectionWithPriority() {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
	RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
	RootBeanDefinition bd2 = new RootBeanDefinition(LowPriorityTestBean.class);
	RootBeanDefinition bd3 = new RootBeanDefinition(NullTestBeanFactoryBean.class);
	RootBeanDefinition bd4 = new RootBeanDefinition(TestBeanRecipient.class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR, false);
	lbf.registerBeanDefinition("bd1", bd1);
	lbf.registerBeanDefinition("bd2", bd2);
	lbf.registerBeanDefinition("bd3", bd3);
	lbf.registerBeanDefinition("bd4", bd4);
	lbf.preInstantiateSingletons();
	TestBean bean = lbf.getBean(TestBeanRecipient.class).testBean;
	assertThat(bean.getBeanName(), equalTo("bd1"));
}
 
Example 22
Source Project: spring-analysis-note   Source File: AspectJProxyFactory.java    License: MIT License 5 votes vote down vote up
/**
 * Add all {@link Advisor Advisors} from the supplied {@link MetadataAwareAspectInstanceFactory}
 * to the current chain. Exposes any special purpose {@link Advisor Advisors} if needed.
 * @see AspectJProxyUtils#makeAdvisorChainAspectJCapableIfNecessary(List)
 */
private void addAdvisorsFromAspectInstanceFactory(MetadataAwareAspectInstanceFactory instanceFactory) {
	List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory);
	Class<?> targetClass = getTargetClass();
	Assert.state(targetClass != null, "Unresolvable target class");
	advisors = AopUtils.findAdvisorsThatCanApply(advisors, targetClass);
	AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors);
	AnnotationAwareOrderComparator.sort(advisors);
	addAdvisors(advisors);
}
 
Example 23
Source Project: spring-analysis-note   Source File: ProxyFactoryTests.java    License: MIT License 5 votes vote down vote up
@Test
public void testInterfaceProxiesCanBeOrderedThroughAnnotations() {
	Object proxy1 = new ProxyFactory(new A()).getProxy();
	Object proxy2 = new ProxyFactory(new B()).getProxy();
	List<Object> list = new ArrayList<>(2);
	list.add(proxy1);
	list.add(proxy2);
	AnnotationAwareOrderComparator.sort(list);
	assertSame(proxy2, list.get(0));
	assertSame(proxy1, list.get(1));
}
 
Example 24
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	this.beanFactory = beanFactory;

	Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
	List<EventListenerFactory> factories = new ArrayList<>(beans.values());
	AnnotationAwareOrderComparator.sort(factories);
	this.eventListenerFactories = factories;
}
 
Example 25
/**
 * Delegate the {@code ServletContext} to any {@link WebApplicationInitializer}
 * implementations present on the application classpath.
 * <p>Because this class declares @{@code HandlesTypes(WebApplicationInitializer.class)},
 * Servlet 3.0+ containers will automatically scan the classpath for implementations
 * of Spring's {@code WebApplicationInitializer} interface and provide the set of all
 * such types to the {@code webAppInitializerClasses} parameter of this method.
 * <p>If no {@code WebApplicationInitializer} implementations are found on the classpath,
 * this method is effectively a no-op. An INFO-level log message will be issued notifying
 * the user that the {@code ServletContainerInitializer} has indeed been invoked but that
 * no {@code WebApplicationInitializer} implementations were found.
 * <p>Assuming that one or more {@code WebApplicationInitializer} types are detected,
 * they will be instantiated (and <em>sorted</em> if the @{@link
 * org.springframework.core.annotation.Order @Order} annotation is present or
 * the {@link org.springframework.core.Ordered Ordered} interface has been
 * implemented). Then the {@link WebApplicationInitializer#onStartup(ServletContext)}
 * method will be invoked on each instance, delegating the {@code ServletContext} such
 * that each instance may register and configure servlets such as Spring's
 * {@code DispatcherServlet}, listeners such as Spring's {@code ContextLoaderListener},
 * or any other Servlet API componentry such as filters.
 * @param webAppInitializerClasses all implementations of
 * {@link WebApplicationInitializer} found on the application classpath
 * @param servletContext the servlet context to be initialized
 * @see WebApplicationInitializer#onStartup(ServletContext)
 * @see AnnotationAwareOrderComparator
 */
@Override
public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
		throws ServletException {

	List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>();

	if (webAppInitializerClasses != null) {
		for (Class<?> waiClass : webAppInitializerClasses) {
			// Be defensive: Some servlet containers provide us with invalid classes,
			// no matter what @HandlesTypes says...
			if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
					WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
				try {
					initializers.add((WebApplicationInitializer) waiClass.newInstance());
				}
				catch (Throwable ex) {
					throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
				}
			}
		}
	}

	if (initializers.isEmpty()) {
		servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
		return;
	}

	servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
	AnnotationAwareOrderComparator.sort(initializers);
	for (WebApplicationInitializer initializer : initializers) {
		initializer.onStartup(servletContext);
	}
}
 
Example 26
@Test
public void testGetBeanByTypeWithPriority() throws Exception {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
	RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
	RootBeanDefinition bd2 = new RootBeanDefinition(LowPriorityTestBean.class);
	lbf.registerBeanDefinition("bd1", bd1);
	lbf.registerBeanDefinition("bd2", bd2);
	TestBean bean = lbf.getBean(TestBean.class);
	assertThat(bean.getBeanName(), equalTo("bd1"));
}
 
Example 27
Source Project: grpc-spring-boot-starter   Source File: GRpcServerRunner.java    License: Apache License 2.0 5 votes vote down vote up
private Comparator<Object> serverInterceptorOrderComparator() {
    Function<Object,Boolean> isOrderAnnotated = obj->{
        Order ann = obj instanceof Method ? AnnotationUtils.findAnnotation((Method) obj, Order.class) :
                AnnotationUtils.findAnnotation(obj.getClass(), Order.class);
        return ann != null;
    };
    return AnnotationAwareOrderComparator.INSTANCE.thenComparing((o1, o2) -> {
        boolean p1 = isOrderAnnotated.apply(o1);
        boolean p2 = isOrderAnnotated.apply(o2);
        return p1 && !p2 ? -1 : p2 && !p1 ? 1 : 0;
    }).reversed();
}
 
Example 28
Source Project: spring-analysis-note   Source File: ControllerMethodResolver.java    License: MIT License 5 votes vote down vote up
private void initControllerAdviceCaches(ApplicationContext applicationContext) {
	List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(applicationContext);
	AnnotationAwareOrderComparator.sort(beans);

	for (ControllerAdviceBean bean : beans) {
		Class<?> beanType = bean.getBeanType();
		if (beanType != null) {
			Set<Method> attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
			if (!attrMethods.isEmpty()) {
				this.modelAttributeAdviceCache.put(bean, attrMethods);
			}
			Set<Method> binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
			if (!binderMethods.isEmpty()) {
				this.initBinderAdviceCache.put(bean, binderMethods);
			}
			ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
			if (resolver.hasExceptionMappings()) {
				this.exceptionHandlerAdviceCache.put(bean, resolver);
			}
		}
	}

	if (logger.isDebugEnabled()) {
		int modelSize = this.modelAttributeAdviceCache.size();
		int binderSize = this.initBinderAdviceCache.size();
		int handlerSize = this.exceptionHandlerAdviceCache.size();
		if (modelSize == 0 && binderSize == 0 && handlerSize == 0) {
			logger.debug("ControllerAdvice beans: none");
		}
		else {
			logger.debug("ControllerAdvice beans: " + modelSize + " @ModelAttribute, " + binderSize +
					" @InitBinder, " + handlerSize + " @ExceptionHandler");
		}
	}
}
 
Example 29
@Test
public void listenersInOrder() {
	assertThat(context).isInstanceOf(AbstractApplicationContext.class);
	AbstractApplicationContext ctxt = (AbstractApplicationContext) context;
	List<ApplicationListener<?>> applicationListeners = new ArrayList<>(
			ctxt.getApplicationListeners());
	AnnotationAwareOrderComparator.sort(applicationListeners);
	int weightFilterIndex = applicationListeners
			.indexOf(context.getBean(WeightCalculatorWebFilter.class));
	int routeLocatorIndex = applicationListeners
			.indexOf(context.getBean(CachingRouteLocator.class));
	assertThat(weightFilterIndex > routeLocatorIndex)
			.as("CachingRouteLocator is after WeightCalculatorWebFilter").isTrue();
}
 
Example 30
Source Project: spring4-understanding   Source File: DispatcherServlet.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Initialize the HandlerMappings used by this class.
 * <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
 * we default to BeanNameUrlHandlerMapping.
 */
private void initHandlerMappings(ApplicationContext context) {
	this.handlerMappings = null;

	if (this.detectAllHandlerMappings) {
		// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
		Map<String, HandlerMapping> matchingBeans =
				BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
		if (!matchingBeans.isEmpty()) {
			this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
			// We keep HandlerMappings in sorted order.
			AnnotationAwareOrderComparator.sort(this.handlerMappings);
		}
	}
	else {
		try {
			HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
			this.handlerMappings = Collections.singletonList(hm);
		}
		catch (NoSuchBeanDefinitionException ex) {
			// Ignore, we'll add a default HandlerMapping later.
		}
	}

	// Ensure we have at least one HandlerMapping, by registering
	// a default HandlerMapping if no other mappings are found.
	if (this.handlerMappings == null) {
		this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
		if (logger.isDebugEnabled()) {
			logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
		}
	}
}