public class SingletonTargetSource implements TargetSource, Serializable {
 
 /** Target cached and invoked using reflection. */
 private final Object target;
 //省略无关代码......
 @Override
 public Object getTarget() {
  return this.target;
 }
 //省略无关代码......
 }

 public class PrototypeTargetSource extends AbstractPrototypeBasedTargetSource {
 
 /**
 * Obtain a new prototype instance for every call.
 * @see #newPrototypeInstance()
 */
 @Override
 public Object getTarget() throws BeansException {
  return newPrototypeInstance();
 }
 
 /**
 * Destroy the given independent instance.
 * @see #destroyPrototypeInstance
 */
 @Override
 public void releaseTarget(Object target) {
  destroyPrototypeInstance(target);
 }
 //省略无关代码......
 }

 public abstract class AbstractPrototypeBasedTargetSource extends AbstractBeanFactoryBasedTargetSource {
 
 //省略无关代码......
 /**
 * Subclasses should call this method to create a new prototype instance.
 * @throws BeansException if bean creation failed
 */
 protected Object newPrototypeInstance() throws BeansException {
  if (logger.isDebugEnabled()) {
  logger.debug("Creating new instance of bean '" + getTargetBeanName() + "'");
  }
  return getBeanFactory().getBean(getTargetBeanName());
 }
 
 /**
 * Subclasses should call this method to destroy an obsolete prototype instance.
 * @param target the bean instance to destroy
 */
 protected void destroyPrototypeInstance(Object target) {
  if (logger.isDebugEnabled()) {
  logger.debug("Destroying instance of bean '" + getTargetBeanName() + "'");
  }
  if (getBeanFactory() instanceof ConfigurableBeanFactory) {
  ((ConfigurableBeanFactory) getBeanFactory()).destroyBean(getTargetBeanName(), target);
  }
  else if (target instanceof DisposableBean) {
  try {
  ((DisposableBean) target).destroy();
  }
  catch (Throwable ex) {
  logger.warn("Destroy method on bean with name '" + getTargetBeanName() + "' threw an exception", ex);
  }
  }
 }
 
 //省略无关代码......
 
 }

 public class ThreadLocalTargetSource extends AbstractPrototypeBasedTargetSource
  implements ThreadLocalTargetSourceStats, DisposableBean {
 
 /**
 * ThreadLocal holding the target associated with the current
 * thread. Unlike most ThreadLocals, which are static, this variable
 * is meant to be per thread per instance of the ThreadLocalTargetSource class.
 */
 private final ThreadLocal<Object> targetInThread =
  new NamedThreadLocal<>("Thread-local instance of bean '" + getTargetBeanName() + "'");
 
 /**
 * Set of managed targets, enabling us to keep track of the targets we've created.
 */
 private final Set<Object> targetSet = new HashSet<>();
 
 //省略无关代码......
 /**
 * Implementation of abstract getTarget() method.
 * We look for a target held in a ThreadLocal. If we don't find one,
 * we create one and bind it to the thread. No synchronization is required.
 */
 @Override
 public Object getTarget() throws BeansException {
  ++this.invocationCount;
  Object target = this.targetInThread.get();
  if (target == null) {
  if (logger.isDebugEnabled()) {
  logger.debug("No target for prototype '" + getTargetBeanName() + "' bound to thread: " +
   "creating one and binding it to thread '" + Thread.currentThread().getName() + "'");
  }
  // Associate target with ThreadLocal.
  target = newPrototypeInstance();
  this.targetInThread.set(target);
  synchronized (this.targetSet) {
  this.targetSet.add(target);
  }
  }
  else {
  ++this.hitCount;
  }
  return target;
 }
 
 /**
 * Dispose of targets if necessary; clear ThreadLocal.
 * @see #destroyPrototypeInstance
 */
 @Override
 public void destroy() {
  logger.debug("Destroying ThreadLocalTargetSource bindings");
  synchronized (this.targetSet) {
  for (Object target : this.targetSet) {
  destroyPrototypeInstance(target);
  }
  this.targetSet.clear();
  }
  // Clear ThreadLocal, just in case.
  this.targetInThread.remove();
 }
 //省略无关代码......
 }

 package com.github.dqqzj.springboot.target;
 
 import org.springframework.aop.TargetSource;
 import org.springframework.util.Assert;
 
 import java.lang.reflect.Array;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
 * @author qinzhongjian
 * @date created in 2019-08-25 12:43
 * @description: TODO
 * @since JDK 1.8.0_212-b10z
 */
 public class DqqzjTargetSource implements TargetSource {
 private final AtomicInteger idx = new AtomicInteger();
 private final Object[] target;;
 public DqqzjTargetSource(Object[] target) {
  Assert.notNull(target, "Target object must not be null");
  this.target = target;
 }
 @Override
 public Class<?> getTargetClass() {
  return target.getClass();
 }
 
 @Override
 public boolean isStatic() {
  return false;
 }
 
 @Override
 public Object getTarget() throws Exception {
  return this.target[this.idx.getAndIncrement() & this.target.length - 1];
 }
 
 @Override
 public void releaseTarget(Object target) throws Exception {
 
 }
 }