下面列出了怎么用org.springframework.beans.BeansException的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
StringBuilder builder= new StringBuilder("Available algorithms: \n");
for (PredictionAlgorithm inc : applicationContext.getBeansOfType(PredictionAlgorithm.class).values()){
builder.append('\t');
builder.append(inc.getClass());
builder.append('\n');
}
builder.append("Available feature transformers: \n");
for(FeatureTransformer f : applicationContext.getBeansOfType(FeatureTransformer.class).values()){
builder.append('\t');
builder.append(f.getClass());
builder.append('\n');
}
logger.info(builder.toString());
}
@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
if (System.getSecurityManager() != null && (bean instanceof DisruptorEventPublisherAware )) {
acc = getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareInterfaces(bean);
return null;
}
}, acc);
}
else {
invokeAwareInterfaces(bean);
}
return bean;
}
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
Environment env = applicationContext.getEnvironment();
applicationContext.getBeanFactory().addBeanPostProcessor(new InstantiationAwareBeanPostProcessorAdapter() {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof RedisTemplate) {
RedisTemplate redisTemplate = (RedisTemplate)bean;
// do cache
redisTemplate.opsForValue();
redisTemplate.opsForList();
redisTemplate.opsForSet();
redisTemplate.opsForZSet();
redisTemplate.opsForGeo();
redisTemplate.opsForHash();
redisTemplate.opsForHyperLogLog();
createProxyHandlers(redisTemplate);
}
return bean;
}
});
}
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (annotationPackage == null || annotationPackage.length() == 0) {
return;
}
if (beanFactory instanceof BeanDefinitionRegistry) {
try {
// init scanner
Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
Object scanner = scannerClass.getConstructor(new Class<?>[] {BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[] {(BeanDefinitionRegistry) beanFactory, true});
// add filter
Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");
Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);
Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));
addIncludeFilter.invoke(scanner, filter);
// scan packages
String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});
scan.invoke(scanner, new Object[] {packages});
} catch (Throwable e) {
// spring 2.0
}
}
}
/**
* 封装ScheduledMethodRunnable对象
*/
private ScheduledMethodRunnable buildScheduledRunnable(String targetBean, String targetMethod, String params, String extKeySuffix) {
Object bean;
ScheduledMethodRunnable scheduledMethodRunnable;
final String scheduleKey = ScheduleUtil.buildScheduleKey(targetBean, targetMethod, extKeySuffix);
try {
bean = applicationContext.getBean(targetBean);
} catch (BeansException e) {
zkClient.getTaskGenerator().getScheduleTask().saveRunningInfo(scheduleKey, ScheduleServer.getInstance().getUuid(), e.getLocalizedMessage());
log.error("启动动态任务失败: {}, 失败原因: {}", scheduleKey, e.getLocalizedMessage());
log.error(e.getLocalizedMessage(), e);
return null;
}
scheduledMethodRunnable = buildScheduledRunnable(bean, targetMethod, params, extKeySuffix, scheduleKey);
return scheduledMethodRunnable;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean == null) {
return bean;
}
if (bean instanceof TurboClientAware) {
((TurboClientAware) bean).setTurboClient(turboClient);
}
Class<?> clazz = bean.getClass();
TurboFailover turboFailover = clazz.getAnnotation(TurboFailover.class);
if (turboFailover == null) {
return bean;
}
if (logger.isInfoEnabled()) {
logger.info("扫描到Failover实例,重置TurboFailover: " + clazz.getName() + turboFailover);
}
turboClient.setFailover(turboFailover.service(), bean);
return bean;
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
if (isLogEnabled()) {
String[] beanNames = beanFactory.getBeanDefinitionNames();
for (String beanName : beanNames) {
String nameToLookup = beanName;
if (beanFactory.isFactoryBean(beanName)) {
nameToLookup = BeanFactory.FACTORY_BEAN_PREFIX + beanName;
}
Class<?> beanType = ClassUtils.getUserClass(beanFactory.getType(nameToLookup));
if (beanType != null && beanType.isAnnotationPresent(Deprecated.class)) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
logDeprecatedBean(beanName, beanType, beanDefinition);
}
}
}
}
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
functionDescriptorMap.clear();
functionDescriptorLabelMap.clear();
Collection<FunctionDescriptor> functionDescriptors=applicationContext.getBeansOfType(FunctionDescriptor.class).values();
for(FunctionDescriptor fun:functionDescriptors){
if(fun.isDisabled()){
continue;
}
if(functionDescriptorMap.containsKey(fun.getName())){
throw new RuntimeException("Duplicate function ["+fun.getName()+"]");
}
functionDescriptorMap.put(fun.getName(), fun);
functionDescriptorLabelMap.put(fun.getLabel(), fun);
}
debugWriters=applicationContext.getBeansOfType(DebugWriter.class).values();
Utils.applicationContext=applicationContext;
new Splash().print();
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
Class clazz = bean.getClass();
for (Field field : findAllField(clazz)) {
processField(bean, beanName, field);
}
for (Method method : findAllMethod(clazz)) {
processMethod(bean, beanName, method);
}
return bean;
}
/**
* Retrieve all bean of type {@code T} from the given {@code BeanFactory} declaring a
* qualifier (e.g. via {@code <qualifier>} or {@code @Qualifier}) matching the given
* qualifier, or having a bean name matching the given qualifier.
* @param beanFactory the factory to get the target beans from (also searching ancestors)
* @param beanType the type of beans to retrieve
* @param qualifier the qualifier for selecting among all type matches
* @return the matching beans of type {@code T}
* @throws BeansException if any of the matching beans could not be created
* @since 5.1.1
* @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
*/
public static <T> Map<String, T> qualifiedBeansOfType(
ListableBeanFactory beanFactory, Class<T> beanType, String qualifier) throws BeansException {
String[] candidateBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, beanType);
Map<String, T> result = new LinkedHashMap<>(4);
for (String beanName : candidateBeans) {
if (isQualifierMatch(qualifier::equals, beanName, beanFactory)) {
result.put(beanName, beanFactory.getBean(beanName, beanType));
}
}
return result;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
super.setBeanFactory(beanFactory);
if (beanFactory instanceof ConfigurableListableBeanFactory) {
filenameToPropsMap = loadQConfigFilesInAnnotation((ConfigurableListableBeanFactory) beanFactory, beanClassLoader);
}
}
@Override
@Async
public Future<Void> release(VirtualNetworkFunctionRecord virtualNetworkFunctionRecord)
throws NotFoundException, BadFormatException, ExecutionException, InterruptedException {
VnfmManagerEndpoint endpoint = generator.getVnfm(virtualNetworkFunctionRecord.getEndpoint());
if (endpoint == null) {
throw new NotFoundException(
"VnfManager of type "
+ virtualNetworkFunctionRecord.getType()
+ " (endpoint = "
+ virtualNetworkFunctionRecord.getEndpoint()
+ ") is not registered");
}
OrVnfmGenericMessage orVnfmGenericMessage =
new OrVnfmGenericMessage(virtualNetworkFunctionRecord, Action.RELEASE_RESOURCES);
VnfmSender vnfmSender;
try {
vnfmSender = generator.getVnfmSender(endpoint.getEndpointType());
} catch (BeansException e) {
throw new NotFoundException(e);
}
vnfStateHandler.executeAction(vnfmSender.sendCommand(orVnfmGenericMessage, endpoint));
return new AsyncResult<>(null);
}
/**
* Create a new instance of the {@link SQLErrorCodesFactory} class.
* <p>Not public to enforce Singleton design pattern. Would be private
* except to allow testing via overriding the
* {@link #loadResource(String)} method.
* <p><b>Do not subclass in application code.</b>
* @see #loadResource(String)
*/
protected SQLErrorCodesFactory() {
Map<String, SQLErrorCodes> errorCodes;
try {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setBeanClassLoader(getClass().getClassLoader());
XmlBeanDefinitionReader bdr = new XmlBeanDefinitionReader(lbf);
// Load default SQL error codes.
Resource resource = loadResource(SQL_ERROR_CODE_DEFAULT_PATH);
if (resource != null && resource.exists()) {
bdr.loadBeanDefinitions(resource);
}
else {
logger.warn("Default sql-error-codes.xml not found (should be included in spring.jar)");
}
// Load custom SQL error codes, overriding defaults.
resource = loadResource(SQL_ERROR_CODE_OVERRIDE_PATH);
if (resource != null && resource.exists()) {
bdr.loadBeanDefinitions(resource);
logger.info("Found custom sql-error-codes.xml file at the root of the classpath");
}
// Check all beans of type SQLErrorCodes.
errorCodes = lbf.getBeansOfType(SQLErrorCodes.class, true, false);
if (logger.isInfoEnabled()) {
logger.info("SQLErrorCodes loaded: " + errorCodes.keySet());
}
}
catch (BeansException ex) {
logger.warn("Error loading SQL error codes from config file", ex);
errorCodes = Collections.emptyMap();
}
this.errorCodesMap = errorCodes;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if("calculateService".equals(beanName)) {
Utils.printTrack("do postProcess before initialization");
CalculateService calculateService = (CalculateService)bean;
calculateService.setServiceDesc("desc from " + this.getClass().getSimpleName());
}
return bean;
}
/**
* Spring allows a parent ApplicationContext to be set during the creation of a new ApplicationContext
*
* Sakai sets the SakaiApplicationContext as the parent which managed by the ComponentManager
*
* @param servletContext (not used)
* @return the shared SakaiApplicationContext
*/
@Override
protected ApplicationContext loadParentContext(ServletContext servletContext) throws BeansException
{
// get the component manager (we know it's a SpringCompMgr) and from that the shared AC
ConfigurableApplicationContext sharedAc = ((SpringCompMgr) ComponentManager.getInstance()).getApplicationContext();
return sharedAc;
}
@Override
public ChromeDriver getObject() throws BeansException {
if (properties.getChrome().isEnabled()) {
try {
return new ChromeDriver(chromeDriverService);
} catch (IllegalStateException e) {
e.printStackTrace();
// swallow the exception
}
}
return null;
}
@Override
public void setApplicationContext(ApplicationContext ctx)
throws BeansException {
System.out.println("setApplicationContext called");
System.out.println("setApplicationContext:: Bean Definition Names="
+ Arrays.toString(ctx.getBeanDefinitionNames()));
}
private void checkLayerTree(ClientMapInfo map) throws BeansException {
// if the map contains a layer tree, verify that the layers are part of the map
ClientLayerTreeInfo layerTree = map.getLayerTree();
if (null != layerTree) {
checkTreeNode(map, layerTree.getTreeNode());
}
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
ContextHierarchyDirtiesContextTests.context = applicationContext;
ContextHierarchyDirtiesContextTests.baz = applicationContext.getBean("bean", String.class);
ContextHierarchyDirtiesContextTests.bar = applicationContext.getParent().getBean("bean", String.class);
ContextHierarchyDirtiesContextTests.foo = applicationContext.getParent().getParent().getBean("bean", String.class);
}
/**
* Return a merged RootBeanDefinition, traversing the parent bean definition
* if the specified bean corresponds to a child bean definition.
* @param beanName the name of the bean to retrieve the merged definition for
* @return a (potentially merged) RootBeanDefinition for the given bean
* @throws NoSuchBeanDefinitionException if there is no bean with the given name
* @throws BeanDefinitionStoreException in case of an invalid bean definition
*/
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
@Bean
public BeanPostProcessor gemfireCacheSslConfigurationBeanPostProcessor() {
return new BeanPostProcessor() {
@Nullable @Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
Optional.ofNullable(bean)
.filter(GemFireCache.class::isInstance)
.map(GemFireCache.class::cast)
.map(GemFireCache::getDistributedSystem)
.filter(InternalDistributedSystem.class::isInstance)
.map(InternalDistributedSystem.class::cast)
.map(InternalDistributedSystem::getConfig)
.ifPresent(distributionConfig -> {
SecurableCommunicationChannel[] securableCommunicationChannels =
ArrayUtils.nullSafeArray(distributionConfig.getSecurableCommunicationChannels(),
SecurableCommunicationChannel.class);
logger.error("SECURABLE COMMUNICATION CHANNELS {}",
Arrays.toString(securableCommunicationChannels));
Arrays.stream(securableCommunicationChannels).forEach(securableCommunicationChannel -> {
SSLConfig sslConfig = SSLConfigurationFactory
.getSSLConfigForComponent(distributionConfig, securableCommunicationChannel);
logger.error("{} SSL CONFIGURATION [{}]", securableCommunicationChannel.name(), sslConfig);
});
});
return bean;
}
};
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof PersonnelAuthenticationSupplier) {
PersonnelAuthenticationHolder.addSupplier(((PersonnelAuthenticationSupplier) bean));
}
return bean;
}
/**
* Get property value null if none
* @param bean beam
* @param name name
* @return the property value
*/
public static Object getProperty(Object bean, String name) {
try {
BeanWrapper wrapper = new BeanWrapperImpl(bean);
return wrapper.getPropertyValue(name);
} catch (BeansException be) {
log.error(be);
return null;
}
}
/**
* Register a singleton bean with the underlying bean factory.
* <p>For more advanced needs, register with the underlying BeanFactory directly.
* @see #getDefaultListableBeanFactory
*/
public void registerSingleton(String name, Class<?> clazz, MutablePropertyValues pvs) throws BeansException {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(clazz);
bd.setPropertyValues(pvs);
getDefaultListableBeanFactory().registerBeanDefinition(name, bd);
}
/**
* 预初始化 初始化之前调用
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("annotationBean".equals(beanName)){
LOGGER.info("SpringLifeCycleProcessor start beanName={}",beanName);
}
return bean;
}
@Override
public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
throws BeansException {
Map<String, Object> results = new LinkedHashMap<String, Object>();
for (String beanName : this.beans.keySet()) {
if (findAnnotationOnBean(beanName, annotationType) != null) {
results.put(beanName, getBean(beanName));
}
}
return results;
}
@Test
public void プロフィルが設定されていない場合はBeanFactoryから型一致で検索する() throws Exception {
interceptor.setBeanFactory(new BeanFactoryStub() {
@Override public <T> T getBean(Class<T> requiredType) throws BeansException {
return requiredType.cast(new Profill());
}
});
interceptor.afterPropertiesSet();
assertThat(interceptor.getProfill(), is(notNullValue()));
}
/**
* Initialize the view bean factory from the XML file.
* Synchronized because of access by parallel threads.
* @throws BeansException in case of initialization errors
*/
protected synchronized BeanFactory initFactory() throws BeansException {
if (this.cachedFactory != null) {
return this.cachedFactory;
}
ApplicationContext applicationContext = obtainApplicationContext();
Resource actualLocation = this.location;
if (actualLocation == null) {
actualLocation = applicationContext.getResource(DEFAULT_LOCATION);
}
// Create child ApplicationContext for views.
GenericWebApplicationContext factory = new GenericWebApplicationContext();
factory.setParent(applicationContext);
factory.setServletContext(getServletContext());
// Load XML resource with context-aware entity resolver.
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.setEnvironment(applicationContext.getEnvironment());
reader.setEntityResolver(new ResourceEntityResolver(applicationContext));
reader.loadBeanDefinitions(actualLocation);
factory.refresh();
if (isCache()) {
this.cachedFactory = factory;
}
return factory;
}
/**
* Return a 'merged' BeanDefinition for the given bean name,
* merging a child bean definition with its parent if necessary.
* <p>This {@code getMergedBeanDefinition} considers bean definition
* in ancestors as well.
* @param name the name of the bean to retrieve the merged definition for
* (may be an alias)
* @return a (potentially merged) RootBeanDefinition for the given bean
* @throws NoSuchBeanDefinitionException if there is no bean with the given name
* @throws BeanDefinitionStoreException in case of an invalid bean definition
*/
@Override
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
String beanName = transformedBeanName(name);
// Efficiently check whether bean definition exists in this factory.
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
}
// Resolve merged bean definition locally.
return getMergedLocalBeanDefinition(beanName);
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (!this.afterInitialization) {
doValidate(bean);
}
return bean;
}