@Override
 protected void initServletContext(ServletContext servletContext) {
   Collection<ViewResolver> matchingBeans =
       BeanFactoryUtils.beansOfTypeIncludingAncestors(getApplicationContext(), ViewResolver.class)
           .values();
   if (this.viewResolvers == null) {
     this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.size());
     for (ViewResolver viewResolver : matchingBeans) {
       if (this != viewResolver) {
         this.viewResolvers.add(viewResolver);
       }
     }
   } else {
     for (int i = 0; i < viewResolvers.size(); i++) {
       if (matchingBeans.contains(viewResolvers.get(i))) {
         continue;
       }
       String name = viewResolvers.get(i).getClass().getName() + i;
       getApplicationContext()
           .getAutowireCapableBeanFactory()
           .initializeBean(viewResolvers.get(i), name);
     }
   }
   if (this.viewResolvers.isEmpty()) {
     logger.warn(
         "Did not find any ViewResolvers to delegate to; please configure them using the "
             + "'viewResolvers' property on the ContentNegotiatingViewResolver");
   }
   OrderComparator.sort(this.viewResolvers);
 }
	/**
	 * Initialize the ViewResolvers used by this class.
	 * <p>If no ViewResolver beans are defined in the BeanFactory
	 * for this namespace, we default to InternalResourceViewResolver.
	 */
	private void initViewResolvers(ApplicationContext context) {
		this.viewResolvers = null;

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

		// Ensure we have at least one ViewResolver, by registering
		// a default ViewResolver if no other resolvers are found.
		if (this.viewResolvers == null) {
			this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
			if (logger.isDebugEnabled()) {
				logger.debug("No ViewResolvers found in portlet '" + getPortletName() + "': using default");
			}
		}
	}
	/**
	 * Initialize the HandlerExceptionResolver used by this class.
	 * <p>If no bean is defined with the given name in the BeanFactory
	 * for this namespace, we default to no exception resolver.
	 */
	private void initHandlerExceptionResolvers(ApplicationContext context) {
		this.handlerExceptionResolvers = null;

		if (this.detectAllHandlerExceptionResolvers) {
			// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
					context, HandlerExceptionResolver.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
				// We keep HandlerExceptionResolvers in sorted order.
				OrderComparator.sort(this.handlerExceptionResolvers);
			}
		}
		else {
			try {
				HandlerExceptionResolver her = context.getBean(
						HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
				this.handlerExceptionResolvers = Collections.singletonList(her);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, no HandlerExceptionResolver is fine too.
			}
		}

		// Just for consistency, check for default HandlerExceptionResolvers...
		// There aren't any in usual scenarios.
		if (this.handlerExceptionResolvers == null) {
			this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
			if (logger.isDebugEnabled()) {
				logger.debug("No HandlerExceptionResolvers found in portlet '" + getPortletName() + "': using default");
			}
		}
	}
	/**
	 * Initialize the HandlerAdapters used by this class.
	 * <p>If no HandlerAdapter beans are defined in the BeanFactory
	 * for this namespace, we default to SimpleControllerHandlerAdapter.
	 */
	private void initHandlerAdapters(ApplicationContext context) {
		this.handlerAdapters = null;

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

		// Ensure we have at least some HandlerAdapters, by registering
		// default HandlerAdapters if no other adapters are found.
		if (this.handlerAdapters == null) {
			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
			if (logger.isDebugEnabled()) {
				logger.debug("No HandlerAdapters found in portlet '" + getPortletName() + "': using default");
			}
		}
	}
 private <T> List<T> getOrderedBeans(Class<T> beanType) {
   List<T> components = new ArrayList<T>();
   Map<String, T> beans =
       BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, beanType, true, false);
   if (!beans.isEmpty()) {
     components.addAll(beans.values());
     OrderComparator.sort(components);
   }
   return components;
 }
 /**
  * Load the factory implementations of the given type from the default location, using the given
  * class loader.
  *
  * <p>The returned factories are ordered in accordance with the {@link OrderComparator}.
  *
  * @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)
  */
 public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
   Assert.notNull(factoryClass, "'factoryClass' must not be null");
   if (classLoader == null) {
     classLoader = SpringFactoriesLoader.class.getClassLoader();
   }
   List<String> factoryNames = loadFactoryNames(factoryClass, classLoader);
   if (logger.isTraceEnabled()) {
     logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
   }
   List<T> result = new ArrayList<T>(factoryNames.size());
   for (String factoryName : factoryNames) {
     result.add(instantiateFactory(factoryName, factoryClass, classLoader));
   }
   OrderComparator.sort(result);
   return result;
 }
 /**
  * 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 {
   List<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.
     OrderComparator.sort(synchs);
     return Collections.unmodifiableList(new ArrayList<TransactionSynchronization>(synchs));
   }
 }
示例#8
0
 public void afterPropertiesSet() throws Exception {
   if (usePlaceholderProperties) {
     OrderComparator.sort(loaders);
     for (PropertiesLoaderSupport loader : loaders) {
       PROPERTIES.putAll((Properties) MethodUtils.invokeMethod(loader, "mergeProperties", null));
     }
   }
   PROPERTIES.putAll(mergeProperties());
   // 检查某些关键的配置顶是否存在,不存在就报初始化错误
   String[] keys = this.necessaryConfigs;
   if (keys != null) {
     for (String key : keys) {
       key = StringUtils.trimToEmpty(key);
       if (!PROPERTIES.containsKey(key)) {
         throw new IllegalStateException(
             "Can not find property \"" + key + "\" in configuration file.");
       }
     }
   }
 }