/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.aop.target;

import java.io.Serializable;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.aop.TargetSource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.util.ObjectUtils;

Base class for TargetSource implementations that are based on a Spring BeanFactory, delegating to Spring-managed bean instances.

Subclasses can create prototype instances or lazily access a singleton target, for example. See LazyInitTargetSource and AbstractPrototypeBasedTargetSource's subclasses for concrete strategies.

BeanFactory-based TargetSources are serializable. This involves disconnecting the current target and turning into a SingletonTargetSource.

Author:Juergen Hoeller, Rod Johnson
See Also:
Since:1.1.4
/** * Base class for {@link org.springframework.aop.TargetSource} implementations * that are based on a Spring {@link org.springframework.beans.factory.BeanFactory}, * delegating to Spring-managed bean instances. * * <p>Subclasses can create prototype instances or lazily access a * singleton target, for example. See {@link LazyInitTargetSource} and * {@link AbstractPrototypeBasedTargetSource}'s subclasses for concrete strategies. * * <p>BeanFactory-based TargetSources are serializable. This involves * disconnecting the current target and turning into a {@link SingletonTargetSource}. * * @author Juergen Hoeller * @author Rod Johnson * @since 1.1.4 * @see org.springframework.beans.factory.BeanFactory#getBean * @see LazyInitTargetSource * @see PrototypeTargetSource * @see ThreadLocalTargetSource * @see CommonsPool2TargetSource */
public abstract class AbstractBeanFactoryBasedTargetSource implements TargetSource, BeanFactoryAware, Serializable {
use serialVersionUID from Spring 1.2.7 for interoperability.
/** use serialVersionUID from Spring 1.2.7 for interoperability. */
private static final long serialVersionUID = -4721607536018568393L;
Logger available to subclasses.
/** Logger available to subclasses. */
protected final Log logger = LogFactory.getLog(getClass());
Name of the target bean we will create on each invocation.
/** Name of the target bean we will create on each invocation. */
private String targetBeanName;
Class of the target.
/** Class of the target. */
private volatile Class<?> targetClass;
BeanFactory that owns this TargetSource. We need to hold onto this reference so that we can create new prototype instances as necessary.
/** * BeanFactory that owns this TargetSource. We need to hold onto this * reference so that we can create new prototype instances as necessary. */
private BeanFactory beanFactory;
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.

Params:
  • targetBeanName – name of the target bean in the BeanFactory that owns this interceptor
See Also:
/** * Set the name of the target bean in the factory. * <p>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 {@link SingletonTargetSource}. * @param targetBeanName name of the target bean in the BeanFactory * that owns this interceptor * @see SingletonTargetSource */
public void setTargetBeanName(String targetBeanName) { this.targetBeanName = targetBeanName; }
Return the name of the target bean in the factory.
/** * Return the name of the target bean in the factory. */
public String getTargetBeanName() { return this.targetBeanName; }
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).

/** * Specify the target class explicitly, to avoid any kind of access to the * target bean (for example, to avoid initialization of a FactoryBean instance). * <p>Default is to detect the type automatically, through a {@code getType} * call on the BeanFactory (or even a full {@code getBean} call as fallback). */
public void setTargetClass(Class<?> targetClass) { this.targetClass = targetClass; }
Set the owning BeanFactory. We need to save a reference so that we can use the getBean method on every invocation.
/** * Set the owning BeanFactory. We need to save a reference so that we can * use the {@code getBean} method on every invocation. */
@Override public void setBeanFactory(BeanFactory beanFactory) { if (this.targetBeanName == null) { throw new IllegalStateException("Property 'targetBeanName' is required"); } this.beanFactory = beanFactory; }
Return the owning BeanFactory.
/** * Return the owning BeanFactory. */
public BeanFactory getBeanFactory() { return this.beanFactory; } @Override public Class<?> getTargetClass() { Class<?> targetClass = this.targetClass; if (targetClass != null) { return targetClass; } synchronized (this) { // Full check within synchronization, entering the BeanFactory interaction algorithm only once... targetClass = this.targetClass; if (targetClass == null && this.beanFactory != null) { // Determine type of the target bean. targetClass = this.beanFactory.getType(this.targetBeanName); if (targetClass == null) { if (logger.isTraceEnabled()) { logger.trace("Getting bean with name '" + this.targetBeanName + "' for type determination"); } Object beanInstance = this.beanFactory.getBean(this.targetBeanName); targetClass = beanInstance.getClass(); } this.targetClass = targetClass; } return targetClass; } } @Override public boolean isStatic() { return false; } @Override public void releaseTarget(Object target) throws Exception { // Nothing to do here. }
Copy configuration from the other AbstractBeanFactoryBasedTargetSource object. Subclasses should override this if they wish to expose it.
Params:
  • other – object to copy configuration from
/** * Copy configuration from the other AbstractBeanFactoryBasedTargetSource object. * Subclasses should override this if they wish to expose it. * @param other object to copy configuration from */
protected void copyFrom(AbstractBeanFactoryBasedTargetSource other) { this.targetBeanName = other.targetBeanName; this.targetClass = other.targetClass; this.beanFactory = other.beanFactory; } @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } AbstractBeanFactoryBasedTargetSource otherTargetSource = (AbstractBeanFactoryBasedTargetSource) other; return (ObjectUtils.nullSafeEquals(this.beanFactory, otherTargetSource.beanFactory) && ObjectUtils.nullSafeEquals(this.targetBeanName, otherTargetSource.targetBeanName)); } @Override public int hashCode() { int hashCode = getClass().hashCode(); hashCode = 13 * hashCode + ObjectUtils.nullSafeHashCode(this.beanFactory); hashCode = 13 * hashCode + ObjectUtils.nullSafeHashCode(this.targetBeanName); return hashCode; } @Override public String toString() { StringBuilder sb = new StringBuilder(getClass().getSimpleName()); 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(); } }