org.springframework.beans.factory.FactoryBeanNotInitializedException Java Examples

/**
 * Return the singleton instance of this class's proxy object,
 * lazily creating it if it hasn't been created already.
 * @return the shared singleton proxy
 */
private synchronized Object getSingletonInstance() {
	if (this.singletonInstance == null) {
		this.targetSource = freshTargetSource();
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class<?> targetClass = getTargetClass();
			if (targetClass == null) {
				throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
			}
			setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
		}
		// Initialize the shared singleton instance.
		super.setFrozen(this.freezeProxy);
		this.singletonInstance = getProxy(createAopProxy());
	}
	return this.singletonInstance;
}
 

@Override
@Nullable
public Object getObject() throws IllegalAccessException {
	if (this.fieldObject == null) {
		throw new FactoryBeanNotInitializedException();
	}
	ReflectionUtils.makeAccessible(this.fieldObject);
	if (this.targetObject != null) {
		// instance field
		return this.fieldObject.get(this.targetObject);
	}
	else {
		// class field
		return this.fieldObject.get(null);
	}
}
 

/**
 * Returns the same value each time if the singleton property is set
 * to "true", otherwise returns the value returned from invoking the
 * specified method on the fly.
 */
@Override
@Nullable
public Object getObject() throws Exception {
	if (this.singleton) {
		if (!this.initialized) {
			throw new FactoryBeanNotInitializedException();
		}
		// Singleton: return shared object.
		return this.singletonObject;
	}
	else {
		// Prototype: new object on each call.
		return invokeWithTargetException();
	}
}
 

/**
 * Return the singleton instance of this class's proxy object,
 * lazily creating it if it hasn't been created already.
 * @return the shared singleton proxy
 */
private synchronized Object getSingletonInstance() {
	if (this.singletonInstance == null) {
		this.targetSource = freshTargetSource();
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class<?> targetClass = getTargetClass();
			if (targetClass == null) {
				throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
			}
			setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
		}
		// Initialize the shared singleton instance.
		super.setFrozen(this.freezeProxy);
		this.singletonInstance = getProxy(createAopProxy());
	}
	return this.singletonInstance;
}
 

/**
 * Return the singleton instance of this class's proxy object,
 * lazily creating it if it hasn't been created already.
 * @return the shared singleton proxy
 */
private synchronized Object getSingletonInstance() {
	if (this.singletonInstance == null) {
		this.targetSource = freshTargetSource();
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class<?> targetClass = getTargetClass();
			if (targetClass == null) {
				throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
			}
			setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
		}
		// Initialize the shared singleton instance.
		super.setFrozen(this.freezeProxy);
		this.singletonInstance = getProxy(createAopProxy());
	}
	return this.singletonInstance;
}
 

@Override
@Nullable
public Object getObject() throws IllegalAccessException {
	if (this.fieldObject == null) {
		throw new FactoryBeanNotInitializedException();
	}
	ReflectionUtils.makeAccessible(this.fieldObject);
	if (this.targetObject != null) {
		// instance field
		return this.fieldObject.get(this.targetObject);
	}
	else {
		// class field
		return this.fieldObject.get(null);
	}
}
 

/**
 * Returns the same value each time if the singleton property is set
 * to "true", otherwise returns the value returned from invoking the
 * specified method on the fly.
 */
@Override
@Nullable
public Object getObject() throws Exception {
	if (this.singleton) {
		if (!this.initialized) {
			throw new FactoryBeanNotInitializedException();
		}
		// Singleton: return shared object.
		return this.singletonObject;
	}
	else {
		// Prototype: new object on each call.
		return invokeWithTargetException();
	}
}
 

/**
 * Return the singleton instance of this class's proxy object,
 * lazily creating it if it hasn't been created already.
 * @return the shared singleton proxy
 */
private synchronized Object getSingletonInstance() {
	if (this.singletonInstance == null) {
		this.targetSource = freshTargetSource();
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class<?> targetClass = getTargetClass();
			if (targetClass == null) {
				throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
			}
			setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
		}
		// Initialize the shared singleton instance.
		super.setFrozen(this.freezeProxy);
		this.singletonInstance = getProxy(createAopProxy());
	}
	return this.singletonInstance;
}
 

/**
 * Determine an 'eager singleton' instance, exposed in case of a
 * circular reference. Not called in a non-circular scenario.
 */
@SuppressWarnings("unchecked")
private T getEarlySingletonInstance() throws Exception {
	Class<?>[] ifcs = getEarlySingletonInterfaces();
	if (ifcs == null) {
		throw new FactoryBeanNotInitializedException(
				getClass().getName() + " does not support circular references");
	}
	if (this.earlySingletonInstance == null) {
		this.earlySingletonInstance = (T) Proxy.newProxyInstance(
				this.beanClassLoader, ifcs, new EarlySingletonInvocationHandler());
	}
	return this.earlySingletonInstance;
}
 

/**
 * Creates a ConverterManagerImpl populating it with Converter instances from the converterConfigList property.
 * 
 * @return The newly created {@link org.springframework.ldap.odm.typeconversion.ConverterManager}.
 * @throws ClassNotFoundException Thrown if any of the classes to be converted to or from cannot be found.
 * 
 * @see org.springframework.beans.factory.FactoryBean#getObject()
 */
public Object getObject() throws Exception {
    if (converterConfigList==null) {
        throw new FactoryBeanNotInitializedException("converterConfigList has not been set");
    }
    
    ConverterManagerImpl result = new ConverterManagerImpl();
    for (ConverterConfig converterConfig : converterConfigList) {
        if (converterConfig.fromClasses==null || 
            converterConfig.toClasses==null ||
            converterConfig.converter==null) {
            
            throw new FactoryBeanNotInitializedException(
                    String.format("All of fromClasses, toClasses and converter must be specified in bean %1$s",
                                  converterConfig.toString()));
        }
        for (Class<?> fromClass : converterConfig.fromClasses) {
            for (Class<?> toClass : converterConfig.toClasses) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(String.format("Adding converter from %1$s to %2$s", fromClass, toClass));
                }
                result.addConverter(fromClass, converterConfig.syntax, toClass, converterConfig.converter);
            }
        }
    }
    return result;    
}
 

@Override
public Object getObject() throws IllegalAccessException {
	if (this.fieldObject == null) {
		throw new FactoryBeanNotInitializedException();
	}
	ReflectionUtils.makeAccessible(this.fieldObject);
	if (this.targetObject != null) {
		// instance field
		return this.fieldObject.get(this.targetObject);
	}
	else{
		// class field
		return this.fieldObject.get(null);
	}
}
 

/**
 * Returns the same value each time if the singleton property is set
 * to "true", otherwise returns the value returned from invoking the
 * specified method on the fly.
 */
@Override
public Object getObject() throws Exception {
	if (this.singleton) {
		if (!this.initialized) {
			throw new FactoryBeanNotInitializedException();
		}
		// Singleton: return shared object.
		return this.singletonObject;
	}
	else {
		// Prototype: new object on each call.
		return doInvoke();
	}
}
 

@Override
public Object getObject() {
	if (this.proxy == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}
 

@Override
public Object getObject() {
	if (this.proxy == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}
 

/**
 * Determine an 'eager singleton' instance, exposed in case of a
 * circular reference. Not called in a non-circular scenario.
 */
@SuppressWarnings("unchecked")
private T getEarlySingletonInstance() throws Exception {
	Class<?>[] ifcs = getEarlySingletonInterfaces();
	if (ifcs == null) {
		throw new FactoryBeanNotInitializedException(
				getClass().getName() + " does not support circular references");
	}
	if (this.earlySingletonInstance == null) {
		this.earlySingletonInstance = (T) Proxy.newProxyInstance(
				this.beanClassLoader, ifcs, new EarlySingletonInvocationHandler());
	}
	return this.earlySingletonInstance;
}
 

@Override
public Object getObject() throws IllegalAccessException {
	if (this.fieldObject == null) {
		throw new FactoryBeanNotInitializedException();
	}
	ReflectionUtils.makeAccessible(this.fieldObject);
	if (this.targetObject != null) {
		// instance field
		return this.fieldObject.get(this.targetObject);
	}
	else{
		// class field
		return this.fieldObject.get(null);
	}
}
 

/**
 * Returns the same value each time if the singleton property is set
 * to "true", otherwise returns the value returned from invoking the
 * specified method on the fly.
 */
@Override
public Object getObject() throws Exception {
	if (this.singleton) {
		if (!this.initialized) {
			throw new FactoryBeanNotInitializedException();
		}
		// Singleton: return shared object.
		return this.singletonObject;
	}
	else {
		// Prototype: new object on each call.
		return invokeWithTargetException();
	}
}
 

public void afterPropertiesSet() throws Exception {
       if (ArrayUtils.isEmpty(getProxyInterfaces())) {
           setProxyInterfaces(detectProxyInterfaces());
           if (ArrayUtils.isEmpty(getProxyInterfaces())) {
               throw new FactoryBeanNotInitializedException("Failed to initialize factory bean because " +
                       "proxyInterfaces were not injected or could not be derived from object type.");
           }
       }
       this.proxyObject = Proxy.newProxyInstance(getClass().getClassLoader(), getProxyInterfaces(),
               new LazyInvocationHandler());
}
 

public void afterPropertiesSet() throws Exception {
       if (ArrayUtils.isEmpty(getProxyInterfaces())) {
           setProxyInterfaces(detectProxyInterfaces());
           if (ArrayUtils.isEmpty(getProxyInterfaces())) {
               throw new FactoryBeanNotInitializedException("Failed to initialize factory bean because " +
                       "proxyInterfaces were not injected or could not be derived from object type.");
           }
       }
       this.proxyObject = Proxy.newProxyInstance(getClass().getClassLoader(), getProxyInterfaces(),
               new LazyInvocationHandler());
}
 

public Object getObject() throws Exception {
    if (ldapOperations==null) {
        throw new FactoryBeanNotInitializedException("contextSource ldapOperations property has not been set");
    }
    if (managedClasses==null) {        
        throw new FactoryBeanNotInitializedException("managedClasses property has not been set");
    }
    if (converterManager==null) {        
        throw new FactoryBeanNotInitializedException("converterManager property has not been set");
    }
    
    return new OdmManagerImpl(converterManager, ldapOperations, managedClasses);
}
 

@Override
public Object getObject() {
	if (this.proxy == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}
 

@Override
public boolean isPrototype() {
	if (this.beanFactory == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.beanFactory.isPrototype(this.targetBeanName);
}
 

@Override
public boolean isSingleton() {
	if (this.beanFactory == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.beanFactory.isSingleton(this.targetBeanName);
}
 

@Override
public Object getObject() throws BeansException {
	if (this.beanFactory == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.beanFactory.getBean(this.targetBeanName);
}
 

@Override
public Object getObject() {
	if (this.proxy == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}
 

@Override
public Object getObject() {
	if (this.proxy == null) {
		throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}
 

/**
 * Returns the same value each time if the singleton property is set
 * to "true", otherwise returns the value returned from invoking the
 * specified method on the fly.
 */
@Override
public Object getObject() throws Exception {
	if (this.singleton) {
		if (!this.initialized) {
			throw new FactoryBeanNotInitializedException();
		}
		// Singleton: return shared object.
		return this.singletonObject;
	}
	else {
		// Prototype: new object on each call.
		return invokeWithTargetException();
	}
}
 

@Override
public Object getObject() throws IllegalAccessException {
	if (this.fieldObject == null) {
		throw new FactoryBeanNotInitializedException();
	}
	ReflectionUtils.makeAccessible(this.fieldObject);
	if (this.targetObject != null) {
		// instance field
		return this.fieldObject.get(this.targetObject);
	}
	else {
		// class field
		return this.fieldObject.get(null);
	}
}
 

/**
 * Determine an 'eager singleton' instance, exposed in case of a
 * circular reference. Not called in a non-circular scenario.
 */
@SuppressWarnings("unchecked")
private T getEarlySingletonInstance() throws Exception {
	Class<?>[] ifcs = getEarlySingletonInterfaces();
	if (ifcs == null) {
		throw new FactoryBeanNotInitializedException(
				getClass().getName() + " does not support circular references");
	}
	if (this.earlySingletonInstance == null) {
		this.earlySingletonInstance = (T) Proxy.newProxyInstance(
				this.beanClassLoader, ifcs, new EarlySingletonInvocationHandler());
	}
	return this.earlySingletonInstance;
}
 

/**
 * Determine an 'early singleton' instance, exposed in case of a
 * circular reference. Not called in a non-circular scenario.
 */
@SuppressWarnings("unchecked")
private T getEarlySingletonInstance() throws Exception {
	Class<?>[] ifcs = getEarlySingletonInterfaces();
	if (ifcs == null) {
		throw new FactoryBeanNotInitializedException(
				getClass().getName() + " does not support circular references");
	}
	if (this.earlySingletonInstance == null) {
		this.earlySingletonInstance = (T) Proxy.newProxyInstance(
				this.beanClassLoader, ifcs, new EarlySingletonInvocationHandler());
	}
	return this.earlySingletonInstance;
}