1. 包列表
  2. 类列表
  3. org.springframework.beans.factory.CannotLoadBeanClassException

Java 类org.springframework.beans.factory.CannotLoadBeanClassException 实例源码

项目：spring4-understanding    文件：XmlBeanFactoryTests.java    
/**
 * When using a BeanFactory. singletons are of course not pre-instantiated.
 * So rubbish class names in bean defs must now not be 'resolved' when the
 * bean def is being parsed, 'cos everything on a bean def is now lazy, but
 * must rather only be picked up when the bean is instantiated.
 */
@Test
public void testClassNotFoundWithDefaultBeanClassLoader() {
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    new XmlBeanDefinitionReader(factory).loadBeanDefinitions(CLASS_NOT_FOUND_CONTEXT);
    // cool, no errors, so the rubbish class name in the bean def was not resolved
    try {
        // let's resolve the bean definition; must blow up
        factory.getBean("classNotFound");
        fail("Must have thrown a CannotLoadBeanClassException");
    }
    catch (CannotLoadBeanClassException ex) {
        assertTrue(ex.getResourceDescription().indexOf("classNotFound.xml") != -1);
        assertTrue(ex.getCause() instanceof ClassNotFoundException);
    }
}
项目：class-guard    文件：XmlBeanFactoryTests.java    
/**
 * When using a BeanFactory. singletons are of course not pre-instantiated.
 * So rubbish class names in bean defs must now not be 'resolved' when the
 * bean def is being parsed, 'cos everything on a bean def is now lazy, but
 * must rather only be picked up when the bean is instantiated.
 */
@Test
public void testClassNotFoundWithDefaultBeanClassLoader() {
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    new XmlBeanDefinitionReader(factory).loadBeanDefinitions(CLASS_NOT_FOUND_CONTEXT);
    // cool, no errors, so the rubbish class name in the bean def was not resolved
    try {
        // let's resolve the bean definition; must blow up
        factory.getBean("classNotFound");
        fail("Must have thrown a CannotLoadBeanClassException");
    }
    catch (CannotLoadBeanClassException ex) {
        assertTrue(ex.getResourceDescription().indexOf("classNotFound.xml") != -1);
        assertTrue(ex.getCause() instanceof ClassNotFoundException);
    }
}
项目：lams    文件：MBeanExporter.java    
/**
 * Performs the actual autodetection process, delegating to an
 * {@code AutodetectCallback} instance to vote on the inclusion of a
 * given bean.
 * @param callback the {@code AutodetectCallback} to use when deciding
 * whether to include a bean or not
 */
private void autodetect(AutodetectCallback callback) {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
            try {
                Class<?> beanClass = this.beanFactory.getType(beanName);
                if (beanClass != null && callback.include(beanClass, beanName)) {
                    boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
                    Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
                    if (!this.beans.containsValue(beanName) && (beanInstance == null ||
                            !CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
                        // Not already registered for JMX exposure.
                        this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
                        if (logger.isInfoEnabled()) {
                            logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
                        }
                    }
                }
            }
            catch (CannotLoadBeanClassException ex) {
                if (this.allowEagerInit) {
                    throw ex;
                }
                // otherwise ignore beans where the class is not resolvable
            }
        }
    }
}
项目：lams    文件：AbstractJaxWsServiceExporter.java    
/**
 * Publish all {@link javax.jws.WebService} annotated beans in the
 * containing BeanFactory.
 * @see #publishEndpoint
 */
public void publishEndpoints() {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        try {
            Class<?> type = this.beanFactory.getType(beanName);
            if (type != null && !type.isInterface()) {
                WebService wsAnnotation = type.getAnnotation(WebService.class);
                WebServiceProvider wsProviderAnnotation = type.getAnnotation(WebServiceProvider.class);
                if (wsAnnotation != null || wsProviderAnnotation != null) {
                    Endpoint endpoint = createEndpoint(this.beanFactory.getBean(beanName));
                    if (this.endpointProperties != null) {
                        endpoint.setProperties(this.endpointProperties);
                    }
                    if (this.executor != null) {
                        endpoint.setExecutor(this.executor);
                    }
                    if (wsAnnotation != null) {
                        publishEndpoint(endpoint, wsAnnotation);
                    }
                    else {
                        publishEndpoint(endpoint, wsProviderAnnotation);
                    }
                    this.publishedEndpoints.add(endpoint);
                }
            }
        }
        catch (CannotLoadBeanClassException ex) {
            // ignore beans where the class is not resolvable
        }
    }
}
项目：holon-core    文件：BeanRegistryUtils.java    
/**
 * Get bean class from bean class name.
 * @param beanName Bean name
 * @param beanClassName Bean class naem (not null)
 * @param classLoader ClassLoader to use (null for default class loader)
 * @return Bean class
 * @throws CannotLoadBeanClassException Class name not found in given ClassLoader
 */
private static Class<?> getBeanClass(final String beanName, final String beanClassName, ClassLoader classLoader)
        throws CannotLoadBeanClassException {
    ObjectUtils.argumentNotNull(beanClassName, "Bean class name must be not null");
    try {
        return ClassUtils.forName(beanClassName, classLoader);
    } catch (ClassNotFoundException e) {
        throw new CannotLoadBeanClassException(BeanRegistryUtils.class.getName(), beanName, beanClassName, e);
    }
}
项目：spring4-understanding    文件：MBeanExporter.java    
/**
 * Performs the actual autodetection process, delegating to an
 * {@code AutodetectCallback} instance to vote on the inclusion of a
 * given bean.
 * @param callback the {@code AutodetectCallback} to use when deciding
 * whether to include a bean or not
 */
private void autodetect(AutodetectCallback callback) {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
            try {
                Class<?> beanClass = this.beanFactory.getType(beanName);
                if (beanClass != null && callback.include(beanClass, beanName)) {
                    boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
                    Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
                    if (!ScopedProxyUtils.isScopedTarget(beanName) && !this.beans.containsValue(beanName) &&
                            (beanInstance == null ||
                                    !CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
                        // Not already registered for JMX exposure.
                        this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
                        if (logger.isInfoEnabled()) {
                            logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
                        }
                    }
                }
            }
            catch (CannotLoadBeanClassException ex) {
                if (this.allowEagerInit) {
                    throw ex;
                }
                // otherwise ignore beans where the class is not resolvable
            }
        }
    }
}
项目：spring4-understanding    文件：ClassPathXmlApplicationContextTests.java    
@Test
public void testContextWithInvalidLazyClass() {
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(INVALID_CLASS_CONTEXT, getClass());
    assertTrue(ctx.containsBean("someMessageSource"));
    try {
        ctx.getBean("someMessageSource");
        fail("Should have thrown CannotLoadBeanClassException");
    }
    catch (CannotLoadBeanClassException ex) {
        assertTrue(ex.contains(ClassNotFoundException.class));
    }
    ctx.close();
}
项目：spring4-understanding    文件：AbstractJaxWsServiceExporter.java    
/**
 * Publish all {@link javax.jws.WebService} annotated beans in the
 * containing BeanFactory.
 * @see #publishEndpoint
 */
public void publishEndpoints() {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        try {
            Class<?> type = this.beanFactory.getType(beanName);
            if (type != null && !type.isInterface()) {
                WebService wsAnnotation = type.getAnnotation(WebService.class);
                WebServiceProvider wsProviderAnnotation = type.getAnnotation(WebServiceProvider.class);
                if (wsAnnotation != null || wsProviderAnnotation != null) {
                    Endpoint endpoint = createEndpoint(this.beanFactory.getBean(beanName));
                    if (this.endpointProperties != null) {
                        endpoint.setProperties(this.endpointProperties);
                    }
                    if (this.executor != null) {
                        endpoint.setExecutor(this.executor);
                    }
                    if (wsAnnotation != null) {
                        publishEndpoint(endpoint, wsAnnotation);
                    }
                    else {
                        publishEndpoint(endpoint, wsProviderAnnotation);
                    }
                    this.publishedEndpoints.add(endpoint);
                }
            }
        }
        catch (CannotLoadBeanClassException ex) {
            // ignore beans where the class is not resolvable
        }
    }
}
项目：my-spring-cache-redis    文件：MBeanExporter.java    
/**
 * Performs the actual autodetection process, delegating to an
 * {@code AutodetectCallback} instance to vote on the inclusion of a
 * given bean.
 * @param callback the {@code AutodetectCallback} to use when deciding
 * whether to include a bean or not
 */
private void autodetect(AutodetectCallback callback) {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
            try {
                Class<?> beanClass = this.beanFactory.getType(beanName);
                if (beanClass != null && callback.include(beanClass, beanName)) {
                    boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
                    Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
                    if (!this.beans.containsValue(beanName) && (beanInstance == null ||
                            !CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
                        // Not already registered for JMX exposure.
                        this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
                        if (logger.isInfoEnabled()) {
                            logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
                        }
                    }
                }
            }
            catch (CannotLoadBeanClassException ex) {
                if (this.allowEagerInit) {
                    throw ex;
                }
                // otherwise ignore beans where the class is not resolvable
            }
        }
    }
}
项目：spring    文件：MBeanExporter.java    
/**
 * Performs the actual autodetection process, delegating to an
 * {@code AutodetectCallback} instance to vote on the inclusion of a
 * given bean.
 * @param callback the {@code AutodetectCallback} to use when deciding
 * whether to include a bean or not
 */
private void autodetect(AutodetectCallback callback) {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
            try {
                Class<?> beanClass = this.beanFactory.getType(beanName);
                if (beanClass != null && callback.include(beanClass, beanName)) {
                    boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
                    Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
                    if (!ScopedProxyUtils.isScopedTarget(beanName) && !this.beans.containsValue(beanName) &&
                            (beanInstance == null ||
                                    !CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
                        // Not already registered for JMX exposure.
                        this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
                        if (logger.isInfoEnabled()) {
                            logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
                        }
                    }
                }
            }
            catch (CannotLoadBeanClassException ex) {
                if (this.allowEagerInit) {
                    throw ex;
                }
                // otherwise ignore beans where the class is not resolvable
            }
        }
    }
}
项目：perecoder    文件：PropertiesToDataSourceDescriptorConverter.java    
/**
 * Возвращает название класса по его имени
 *
 * @param className название класса
 * @return Возвращает класс
 */
private static Class<?> retrieveClassByName(String className) {
    try {
        return Class.forName(className);
    } catch (ClassNotFoundException ex) {
        throw new CannotLoadBeanClassException(null, null, className, ex);
    }
}
项目：class-guard    文件：MBeanExporter.java    
/**
 * Performs the actual autodetection process, delegating to an
 * {@code AutodetectCallback} instance to vote on the inclusion of a
 * given bean.
 * @param callback the {@code AutodetectCallback} to use when deciding
 * whether to include a bean or not
 */
private void autodetect(AutodetectCallback callback) {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
            try {
                Class<?> beanClass = this.beanFactory.getType(beanName);
                if (beanClass != null && callback.include(beanClass, beanName)) {
                    boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
                    Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
                    if (!this.beans.containsValue(beanName) && (beanInstance == null ||
                            !CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
                        // Not already registered for JMX exposure.
                        this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
                        if (logger.isInfoEnabled()) {
                            logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
                        }
                    }
                }
            }
            catch (CannotLoadBeanClassException ex) {
                if (this.allowEagerInit) {
                    throw ex;
                }
                // otherwise ignore beans where the class is not resolvable
            }
        }
    }
}
项目：class-guard    文件：ClassPathXmlApplicationContextTests.java    
@Test
public void testContextWithInvalidLazyClass() {
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
            INVALID_CLASS_CONTEXT, getClass());
    assertTrue(ctx.containsBean("someMessageSource"));
    try {
        ctx.getBean("someMessageSource");
        fail("Should have thrown CannotLoadBeanClassException");
    }
    catch (CannotLoadBeanClassException ex) {
        assertTrue(ex.contains(ClassNotFoundException.class));
    }
    ctx.close();
}
项目：class-guard    文件：AbstractJaxWsServiceExporter.java    
/**
 * Publish all {@link javax.jws.WebService} annotated beans in the
 * containing BeanFactory.
 * @see #publishEndpoint
 */
public void publishEndpoints() {
    Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
    beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
    if (this.beanFactory instanceof ConfigurableBeanFactory) {
        beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
    }
    for (String beanName : beanNames) {
        try {
            Class<?> type = this.beanFactory.getType(beanName);
            if (type != null && !type.isInterface()) {
                WebService wsAnnotation = type.getAnnotation(WebService.class);
                WebServiceProvider wsProviderAnnotation = type.getAnnotation(WebServiceProvider.class);
                if (wsAnnotation != null || wsProviderAnnotation != null) {
                    Endpoint endpoint = createEndpoint(this.beanFactory.getBean(beanName));
                    if (this.endpointProperties != null) {
                        endpoint.setProperties(this.endpointProperties);
                    }
                    if (this.executor != null) {
                        endpoint.setExecutor(this.executor);
                    }
                    if (wsAnnotation != null) {
                        publishEndpoint(endpoint, wsAnnotation);
                    }
                    else {
                        publishEndpoint(endpoint, wsProviderAnnotation);
                    }
                    this.publishedEndpoints.add(endpoint);
                }
            }
        }
        catch (CannotLoadBeanClassException ex) {
            // ignore beans where the class is not resolvable
        }
    }
}
项目：spring-modular    文件：ParserUtils.java    
public static Class<?> findClassByName(String className, String beanName, ParserContext parserContext) {
    String description = parserContext.getReaderContext().getResource().getDescription();
    try {
        return Class.forName(className);
    } catch (ClassNotFoundException ex) {
        throw new CannotLoadBeanClassException(description, beanName, className, ex);
    }
}
项目：ximplementation-spring    文件：ImplementeeBeanCreationPostProcessor.java    
/**
 * Init {@linkplain #implementorManager} and
 * {@linkplain #implementorBeanNamesMap}.
 * <p>
 * Synchronization for {@linkplain #implementorManager} and
 * {@linkplain #implementorBeanNamesMap} are not necessary, because they are
 * initialized in #setBeanFactory(BeanFactory) which happens before any
 * other actions.
 * </p>
 * 
 * @throws BeansException
 */
protected void initImplementorManagerAndImplementorBeanNamesMap()
        throws BeansException
{
    String[] allBeanNames = beanFactory.getBeanDefinitionNames();

    for (int i = 0; i < allBeanNames.length; i++)
    {
        String beanName = allBeanNames[i];

        Class<?> beanClass = null;

        BeanDefinition beanDefinition = this.beanFactory
                .getBeanDefinition(beanName);
        String beanClassName = beanDefinition.getBeanClassName();

        try
        {
            beanClass = Class.forName(beanClassName);
        }
        catch (ClassNotFoundException e)
        {
            throw new CannotLoadBeanClassException(
                    beanDefinition.getResourceDescription(), beanName,
                    beanClassName, e);
        }

        List<String> implementorBeanNames = this.implementorBeanNamesMap
                .get(beanClass);
        if (implementorBeanNames == null)
        {
            implementorBeanNames = new ArrayList<String>();
            this.implementorBeanNamesMap.put(beanClass,
                    implementorBeanNames);
        }
        implementorBeanNames.add(beanName);

        // Add itself, fix missing itself as an implementor when auto wired
        // class is not abstract
        this.implementorManager.addFor(beanClass, beanClass);
        this.implementorManager.add(beanClass);
    }
}