/**
 * 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;
}
 

@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
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 '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;
}
 

@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 '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;
}
 

/**
 * 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();
	}
}
 

@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;
}
 

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

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

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

/**
 * 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 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();
	}
}