protected  void copyFrom(AbstractBeanFactoryBasedTargetSource other) 
{
		this.targetBeanName = other.targetBeanName;
		this.targetClass = other.targetClass;
		this.beanFactory = other.beanFactory;
}

Copy configuration from the other AbstractBeanFactoryBasedTargetSource object. Subclasses should override this if they wish to expose it.

 public boolean equals(Object other) 
{
		if (this == other) {
			return true;
		}
		if (other == null || !getClass().equals(other.getClass())) {
			return false;
		}
		AbstractBeanFactoryBasedTargetSource otherTargetSource = (AbstractBeanFactoryBasedTargetSource) other;
		return (ObjectUtils.nullSafeEquals(this.beanFactory, otherTargetSource.beanFactory) &&
				ObjectUtils.nullSafeEquals(this.targetBeanName, otherTargetSource.targetBeanName));
}

 public BeanFactory getBeanFactory() 
{
		return this.beanFactory;
}

Return the owning BeanFactory.

 public String getTargetBeanName() 
{
		return this.targetBeanName;
}

Return the name of the target bean in the factory.

 public synchronized Class getTargetClass() 
{
		if (this.targetClass == null && this.beanFactory != null) {
			// Determine type of the target bean.
			this.targetClass = this.beanFactory.getType(this.targetBeanName);
			if (this.targetClass == null) {
				if (logger.isTraceEnabled()) {
					logger.trace("Getting bean with name '" + this.targetBeanName + "' in order to determine type");
				}
				this.targetClass = this.beanFactory.getBean(this.targetBeanName).getClass();
			}
		}
		return this.targetClass;
}

 public int hashCode() 
{
		int hashCode = getClass().hashCode();
		hashCode = 13 * hashCode + ObjectUtils.nullSafeHashCode(this.beanFactory);
		hashCode = 13 * hashCode + ObjectUtils.nullSafeHashCode(this.targetBeanName);
		return hashCode;
}

 public boolean isStatic() 
{
		return false;
}

 public  void releaseTarget(Object target) throws Exception 
{
		// Nothing to do here.
}

 public  void setBeanFactory(BeanFactory beanFactory) throws BeansException 
{
		if (this.targetBeanName == null) {
			throw new IllegalStateException("Property'targetBeanName' is required");
		}
		this.beanFactory = beanFactory;
}

Set the owning BeanFactory. We need to save a reference so that we can use the getBean method on every invocation.

 public  void setTargetBeanName(String targetBeanName) 
{
	                                                       	 
		this.targetBeanName = targetBeanName;
}

Set the name of the target bean in the factory.

The target bean should not be a singleton, else the same instance will always be obtained from the factory, resulting in the same behavior as provided by SingletonTargetSource .

 public  void setTargetClass(Class targetClass) 
{
		this.targetClass = targetClass;
}

Specify the target class explicitly, to avoid any kind of access to the target bean (for example, to avoid initialization of a FactoryBean instance).

Default is to detect the type automatically, through a getType call on the BeanFactory (or even a full getBean call as fallback).

 public String toString() 
{
		StringBuffer sb = new StringBuffer();
		sb.append(ClassUtils.getShortName(getClass()));
		sb.append(" for target bean '").append(this.targetBeanName).append("'");
		if (this.targetClass != null) {
			sb.append(" of type [").append(this.targetClass.getName()).append("]");
		}
		return sb.toString();
}

 protected Object writeReplace() throws ObjectStreamException 
{
		if (logger.isDebugEnabled()) {
			logger.debug("Disconnecting TargetSource [" + this + "]");
		}
		try {
			// Create disconnected SingletonTargetSource.
			return new SingletonTargetSource(getTarget());
		}
		catch (Exception ex) {
			logger.error("Cannot get target for disconnecting TargetSource [" + this + "]", ex);
			throw new NotSerializableException(
					"Cannot get target for disconnecting TargetSource [" + this + "]: " + ex);
		}
}

Replaces this object with a SingletonTargetSource on serialization. Protected as otherwise it won't be invoked for subclasses. (The writeReplace() method must be visible to the class being serialized.)

With this implementation of this method, there is no need to mark non-serializable fields in this class or subclasses as transient.