protected  void adviceChanged() 
{
		super.adviceChanged();
		if (this.singleton) {
			logger.debug("Advice has changed; recaching singleton instance");
			synchronized (this) {
				this.singletonInstance = null;
			}
		}
}

Blow away and recache singleton on an advice change.

 protected Class createCompositeInterface(Class[] interfaces) 
{
		return ClassUtils.createCompositeInterface(interfaces, this.proxyClassLoader);
}

Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.

The default implementation builds a JDK proxy class for the given interfaces.

 public Object getObject() throws BeansException 
{
		initializeAdvisorChain();
		if (isSingleton()) {
			return getSingletonInstance();
		}
		else {
			if (this.targetName == null) {
				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
						"Enable prototype proxies by setting the 'targetName' property.");
			}
			return newPrototypeInstance();
		}
}

Return a proxy. Invoked when clients obtain beans from this factory bean. Create an instance of the AOP proxy to be returned by this factory. The instance will be cached for a singleton, and create on each call to getObject() for a proxy.

 public Class getObjectType() 
{
		synchronized (this) {
			if (this.singletonInstance != null) {
				return this.singletonInstance.getClass();
			}
		}
		Class[] ifcs = getProxiedInterfaces();
		if (ifcs.length == 1) {
			return ifcs[0];
		}
		else if (ifcs.length  > 1) {
			return createCompositeInterface(ifcs);
		}
		else if (this.targetName != null && this.beanFactory != null) {
			return this.beanFactory.getType(this.targetName);
		}
		else {
			return getTargetClass();
		}
}

Return the type of the proxy. Will check the singleton instance if already created, else fall back to the proxy interface (in case of just a single one), the target bean type, or the TargetSource's target class.

 protected Object getProxy(AopProxy aopProxy) 
{
		return aopProxy.getProxy(this.proxyClassLoader);
}

Return the proxy object to expose.

The default implementation uses a getProxy call with the factory's bean class loader. Can be overridden to specify a custom class loader.

 public boolean isSingleton() 
{
		return this.singleton;
}

 public  void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) 
{
		this.advisorAdapterRegistry = advisorAdapterRegistry;
}

Specify the AdvisorAdapterRegistry to use. Default is the global AdvisorAdapterRegistry.

 public  void setAutodetectInterfaces(boolean autodetectInterfaces) 
{
		this.autodetectInterfaces = autodetectInterfaces;
}

Set whether to autodetect proxy interfaces if none specified.

Default is "true". Turn this flag off to create a CGLIB proxy for the full target class if no interfaces specified.

 public  void setBeanClassLoader(ClassLoader classLoader) 
{
		if (!this.classLoaderConfigured) {
			this.proxyClassLoader = classLoader;
		}
}

 public  void setBeanFactory(BeanFactory beanFactory) 
{
		this.beanFactory = beanFactory;
		checkInterceptorNames();
}

 public  void setFrozen(boolean frozen) 
{
		this.freezeProxy = frozen;
}

 public  void setInterceptorNames(String[] interceptorNames) 
{
		this.interceptorNames = interceptorNames;
}

Set the list of Advice/Advisor bean names. This must always be set to use this factory bean in a bean factory.

The referenced beans should be of type Interceptor, Advisor or Advice The last entry in the list can be the name of any bean in the factory. If it's neither an Advice nor an Advisor, a new SingletonTargetSource is added to wrap it. Such a target bean cannot be used if the "target" or "targetSource" or "targetName" property is set, in which case the "interceptorNames" array must contain only Advice/Advisor bean names.

NOTE: Specifying a target bean as final name in the "interceptorNames" list is deprecated and will be removed in a future Spring version. Use the "targetName" property instead.

 public  void setProxyClassLoader(ClassLoader classLoader) 
{
		this.proxyClassLoader = classLoader;
		this.classLoaderConfigured = (classLoader != null);
}

Set the ClassLoader to generate the proxy class in.

Default is the bean ClassLoader, i.e. the ClassLoader used by the containing BeanFactory for loading all bean classes. This can be overridden here for specific proxies.

 public  void setProxyInterfaces(Class[] proxyInterfaces) throws ClassNotFoundException 
{
	                                      	 
		setInterfaces(proxyInterfaces);
}

Set the names of the interfaces we're proxying. If no interface is given, a CGLIB for the actual class will be created.

This is essentially equivalent to the "setInterfaces" method, but mirrors TransactionProxyFactoryBean's "setProxyInterfaces".

 public  void setSingleton(boolean singleton) 
{
		this.singleton = singleton;
}

Set the value of the singleton property. Governs whether this factory should always return the same proxy instance (which implies the same target) or whether it should return a new prototype instance, which implies that the target and interceptors may be new instances also, if they are obtained from prototype bean definitions. This allows for fine control of independence/uniqueness in the object graph.

 public  void setTargetName(String targetName) 
{
		this.targetName = targetName;
}

Set the name of the target bean. This is an alternative to specifying the target name at the end of the "interceptorNames" array.

You can also specify a target object or a TargetSource object directly, via the "target"/"targetSource" property, respectively.