Java BeanInitializationException类代码示例

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
private DataSource getDataSource(ApplicationContext applicationContext, Persistence persistenceSettings) {
	DataSource dataSource = null;
	Map<String, DataSource> datasources = applicationContext.getBeansOfType(DataSource.class);
	int dsSize = null != datasources ? datasources.size() : 0;
	if (null != datasources && null != persistenceSettings.getDataSourceName()) {
		dataSource = datasources.get(persistenceSettings.getDataSourceName());
	} else if (null != datasources && dsSize == 1 && null == persistenceSettings.getDataSourceName()){
		dataSource = datasources.values().iterator().next();
	}
	
    if (dataSource == null) {
    	throw new BeanInitializationException(
    			"A datasource is required when starting Quartz-Scheduler in persisted mode. " +
    			"No DS found in map with size: " + dsSize + ", and configured DSName: " + persistenceSettings.getDataSourceName());
    }
    return dataSource;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
protected AbstractShiroFilter createInstance() throws Exception {
	SecurityManager securityManager = getSecurityManager();
	if (securityManager == null){
		throw new BeanInitializationException("SecurityManager property must be set.");
	}

	if (!(securityManager instanceof WebSecurityManager)){
		throw new BeanInitializationException("The security manager does not implement the WebSecurityManager interface.");
	}

	PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
	FilterChainManager chainManager = createFilterChainManager();
	chainResolver.setFilterChainManager(chainManager);
	return new MySpringShiroFilter((WebSecurityManager)securityManager, chainResolver);
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Bean
public Region awsRegion() {
    Region region;
    if(regionString != null && !regionString.isEmpty()) {
        region = RegionUtils.getRegion(regionString);
    } else {
        AwsRegionProvider regionProvider = new DefaultAwsRegionProviderChain();
        region = RegionUtils.getRegion(regionProvider.getRegion());
    }
    
    if(region == null) {
        throw new BeanInitializationException("Unable to determine AWS region");
    }
    
    return region;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
private void createProperties() {
	if (properties == null) {
		properties = (dynamic ? new ChangeableProperties() : new Properties());
		// init properties by copying config admin properties
		try {
			PropertiesUtil.initProperties(localProperties, localOverride, CMUtils.getConfiguration(bundleContext,
					persistentId, initTimeout), properties);
		} catch (IOException ioe) {
			throw new BeanInitializationException("Cannot retrieve configuration for pid=" + persistentId, ioe);
		}

		if (dynamic) {
			// perform eager registration
			registration = CMUtils.registerManagedService(bundleContext, new ConfigurationWatcher(), persistentId);
		}
	}
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
public PropertyValues postProcessPropertyValues(
		PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
		throws BeansException {

	if (!this.validatedBeanNames.contains(beanName)) {
		if (!shouldSkip(this.beanFactory, beanName)) {
			List<String> invalidProperties = new ArrayList<String>();
			for (PropertyDescriptor pd : pds) {
				if (isRequiredProperty(pd) && !pvs.contains(pd.getName())) {
					invalidProperties.add(pd.getName());
				}
			}
			if (!invalidProperties.isEmpty()) {
				throw new BeanInitializationException(buildExceptionMessage(invalidProperties, beanName));
			}
		}
		this.validatedBeanNames.add(beanName);
	}
	return pvs;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
/**
 * {@linkplain #mergeProperties Merge}, {@linkplain #convertProperties convert} and
 * {@linkplain #processProperties process} properties against the given bean factory.
 * @throws BeanInitializationException if any properties cannot be loaded
 */
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	try {
		Properties mergedProps = mergeProperties();

		// Convert the merged properties, if necessary.
		convertProperties(mergedProps);

		// Let the subclass process the properties.
		processProperties(beanFactory, mergedProps);
	}
	catch (IOException ex) {
		throw new BeanInitializationException("Could not load properties", ex);
	}
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
protected void processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)
		throws BeansException {

	for (Enumeration<?> names = props.propertyNames(); names.hasMoreElements();) {
		String key = (String) names.nextElement();
		try {
			processKey(beanFactory, key, props.getProperty(key));
		}
		catch (BeansException ex) {
			String msg = "Could not process key '" + key + "' in PropertyOverrideConfigurer";
			if (!this.ignoreInvalidKeys) {
				throw new BeanInitializationException(msg, ex);
			}
			if (logger.isDebugEnabled()) {
				logger.debug(msg, ex);
			}
		}
	}
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
/**
 * Process the given key as 'beanName.property' entry.
 */
protected void processKey(ConfigurableListableBeanFactory factory, String key, String value)
		throws BeansException {

	int separatorIndex = key.indexOf(this.beanNameSeparator);
	if (separatorIndex == -1) {
		throw new BeanInitializationException("Invalid key '" + key +
				"': expected 'beanName" + this.beanNameSeparator + "property'");
	}
	String beanName = key.substring(0, separatorIndex);
	String beanProperty = key.substring(separatorIndex+1);
	this.beanNames.add(beanName);
	applyPropertyValue(factory, beanName, beanProperty, value);
	if (logger.isDebugEnabled()) {
		logger.debug("Property '" + key + "' set to value [" + value + "]");
	}
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    String[] beanNames = beanFactory.getBeanNamesForAnnotation(Job.class);

    for(String name : beanNames){
        JobDetail jobDetail = buildJobForBeanFactory(beanFactory, name);

        if (jobDetail == null){
            logger.warn("could not load JobDetail for {}", name);
            continue;
        }

        try {
            scheduler.addJob(jobDetail, true);
        } catch (SchedulerException e) {
            throw new BeanInitializationException("SchedulerException when adding job to scheduler", e);
        }
    }
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public SamzaContainer samzaContainer() {

    JobModel jobModel = samzaJobModel();

    int containerId = samzaContainerId();
    Assert.isTrue(containerId >= 0, "samzaContainerId must be a non-negative integer (0 or greater).");

    Map<Integer, ContainerModel> containers = jobModel.getContainers();
    ContainerModel containerModel = containers.get(containerId);
    if (containerModel == null) {
        String msg = "Container model does not exist for samza container id '" + containerId + "'.  " +
            "Ensure that samzaContainerId is a zero-based integer less than the total number " +
            "of containers for the job.  Number of containers in the model: " + containers.size();
        throw new BeanInitializationException(msg);
    }

    return SamzaContainer$.MODULE$.apply(containerModel, jobModel);
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	if (bean instanceof Portlet) {
		PortletConfig config = this.portletConfig;
		if (config == null || !this.useSharedPortletConfig) {
			config = new DelegatingPortletConfig(beanName, this.portletContext, this.portletConfig);
		}
		try {
			((Portlet) bean).init(config);
		}
		catch (PortletException ex) {
			throw new BeanInitializationException("Portlet.init threw exception", ex);
		}
	}
	return bean;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
/**
 * Invoked on startup. Looks for a single FreeMarkerConfig bean to
 * find the relevant Configuration for this factory.
 * <p>Checks that the template for the default Locale can be found:
 * FreeMarker will check non-Locale-specific templates if a
 * locale-specific one is not found.
 * @see freemarker.cache.TemplateCache#getTemplate
 */
@Override
protected void initServletContext(ServletContext servletContext) throws BeansException {
	if (getConfiguration() != null) {
		this.taglibFactory = new TaglibFactory(servletContext);
	}
	else {
		FreeMarkerConfig config = autodetectConfiguration();
		setConfiguration(config.getConfiguration());
		this.taglibFactory = config.getTaglibFactory();
	}

	GenericServlet servlet = new GenericServletAdapter();
	try {
		servlet.init(new DelegatingServletConfig());
	}
	catch (ServletException ex) {
		throw new BeanInitializationException("Initialization of GenericServlet adapter failed", ex);
	}
	this.servletContextHashModel = new ServletContextHashModel(servlet, getObjectWrapper());
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	if (bean instanceof Servlet) {
		ServletConfig config = this.servletConfig;
		if (config == null || !this.useSharedServletConfig) {
			config = new DelegatingServletConfig(beanName, this.servletContext);
		}
		try {
			((Servlet) bean).init(config);
		}
		catch (ServletException ex) {
			throw new BeanInitializationException("Servlet.init threw exception", ex);
		}
	}
	return bean;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
/**
 * Return a {@link ContentNegotiationManager} instance to use to determine
 * requested {@linkplain MediaType media types} in a given request.
 */
@Bean
public ContentNegotiationManager mvcContentNegotiationManager() {
	if (this.contentNegotiationManager == null) {
		ContentNegotiationConfigurer configurer = new ContentNegotiationConfigurer(this.servletContext);
		configurer.mediaTypes(getDefaultMediaTypes());
		configureContentNegotiation(configurer);
		try {
			this.contentNegotiationManager = configurer.getContentNegotiationManager();
		}
		catch (Exception ex) {
			throw new BeanInitializationException("Could not create ContentNegotiationManager", ex);
		}
	}
	return this.contentNegotiationManager;
}
 

import org.springframework.beans.factory.BeanInitializationException; //导入依赖的package包/类
/**
 * Create and start a new container using the specified factory.
 */
protected MessageListenerContainer createListenerContainer(JmsListenerEndpoint endpoint,
		JmsListenerContainerFactory<?> factory) {

	MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);

	if (listenerContainer instanceof InitializingBean) {
		try {
			((InitializingBean) listenerContainer).afterPropertiesSet();
		}
		catch (Exception ex) {
			throw new BeanInitializationException("Failed to initialize message listener container", ex);
		}
	}

	int containerPhase = listenerContainer.getPhase();
	if (containerPhase < Integer.MAX_VALUE) {  // a custom phase value
		if (this.phase < Integer.MAX_VALUE && this.phase != containerPhase) {
			throw new IllegalStateException("Encountered phase mismatch between container factory definitions: " +
					this.phase + " vs " + containerPhase);
		}
		this.phase = listenerContainer.getPhase();
	}

	return listenerContainer;
}