序列化表格 (spring-aop 5.0.15.BUILD-SNAPSHOT API)

程序包 org.aopalliance.aop
- 类org.aopalliance.aop.AspectException扩展RuntimeException实现可序列化
程序包 org.springframework.aop
- 类org.springframework.aop.AopInvocationException扩展org.springframework.core.NestedRuntimeException实现可序列化
程序包 org.springframework.aop.aspectj
- 类org.springframework.aop.aspectj.AbstractAspectJAdvice扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream inputStream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - declaringClass
```
Class<T> declaringClass
```
    - methodName
```
String methodName
```
    - parameterTypes
```
Class<T>[] parameterTypes
```
    - pointcut
```
AspectJExpressionPointcut pointcut
```
    - aspectInstanceFactory
```
AspectInstanceFactory aspectInstanceFactory
```
    - aspectName
```
String aspectName
```
      The name of the aspect (ref bean) in which this advice was defined (used when determining advice precedence so that we can determine whether two pieces of advice come from the same aspect).
    - declarationOrder
```
int declarationOrder
```
      The order of declaration of this advice within the aspect.
    - argumentNames
```
String[] argumentNames
```
      This will be non-null if the creator of this advice object knows the argument names and sets them explicitly
    - throwingName
```
String throwingName
```
      Non-null if after throwing advice binds the thrown value
    - returningName
```
String returningName
```
      Non-null if after returning advice binds the return value
    - discoveredReturningType
```
Class<T> discoveredReturningType
```
    - discoveredThrowingType
```
Class<T> discoveredThrowingType
```
    - joinPointArgumentIndex
```
int joinPointArgumentIndex
```
      Index for thisJoinPoint argument (currently only supported at index 0 if present at all)
    - joinPointStaticPartArgumentIndex
```
int joinPointStaticPartArgumentIndex
```
      Index for thisJoinPointStaticPart argument (currently only supported at index 0 if present at all)
    - argumentBindings
```
Map<K,V> argumentBindings
```
    - argumentsIntrospected
```
boolean argumentsIntrospected
```
    - discoveredReturningGenericType
```
Type discoveredReturningGenericType
```
- 类org.springframework.aop.aspectj.AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException扩展RuntimeException实现可序列化
- 类org.springframework.aop.aspectj.AspectJAfterAdvice扩展AbstractAspectJAdvice实现可序列化
- 类org.springframework.aop.aspectj.AspectJAfterReturningAdvice扩展AbstractAspectJAdvice实现可序列化
- 类org.springframework.aop.aspectj.AspectJAfterThrowingAdvice扩展AbstractAspectJAdvice实现可序列化
- 类org.springframework.aop.aspectj.AspectJAroundAdvice扩展AbstractAspectJAdvice实现可序列化
- 类org.springframework.aop.aspectj.AspectJExpressionPointcut扩展AbstractExpressionPointcut实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - pointcutDeclarationScope
```
Class<T> pointcutDeclarationScope
```
    - pointcutParameterNames
```
String[] pointcutParameterNames
```
    - pointcutParameterTypes
```
Class<T>[] pointcutParameterTypes
```
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
- 类org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor扩展AbstractGenericPointcutAdvisor实现可序列化
  - 序列化字段
    - pointcut
```
AspectJExpressionPointcut pointcut
```
- 类org.springframework.aop.aspectj.AspectJMethodBeforeAdvice扩展AbstractAspectJAdvice实现可序列化
- 类org.springframework.aop.aspectj.SingletonAspectInstanceFactory扩展Object实现可序列化
  - 序列化字段
    - aspectInstance
```
Object aspectInstance
```
程序包 org.springframework.aop.aspectj.annotation
- 类org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator扩展AspectJAwareAdvisorAutoProxyCreator实现可序列化
  - 序列化字段
    - includePatterns
```
List<E> includePatterns
```
    - aspectJAdvisorFactory
```
AspectJAdvisorFactory aspectJAdvisorFactory
```
    - aspectJAdvisorsBuilder
```
BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder
```
- 类org.springframework.aop.aspectj.annotation.AspectJProxyFactory扩展ProxyCreatorSupport实现可序列化
  - 序列化字段
    - aspectFactory
```
AspectJAdvisorFactory aspectFactory
```
- 类org.springframework.aop.aspectj.annotation.AspectMetadata扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream inputStream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - aspectName
```
String aspectName
```
      The name of this aspect as defined to Spring (the bean name) - allows us to determine if two pieces of advice come from the same aspect and hence their relative precedence.
    - aspectClass
```
Class<T> aspectClass
```
      The aspect class, stored separately for re-resolution of the corresponding AjType on deserialization.
    - perClausePointcut
```
Pointcut perClausePointcut
```
      Spring AOP pointcut corresponding to the per clause of the aspect. Will be the Pointcut.TRUE canonical instance in the case of a singleton, otherwise an AspectJExpressionPointcut.
- 类org.springframework.aop.aspectj.annotation.BeanFactoryAspectInstanceFactory扩展Object实现可序列化
  - 序列化字段
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
    - name
```
String name
```
    - aspectMetadata
```
AspectMetadata aspectMetadata
```
- 类org.springframework.aop.aspectj.annotation.LazySingletonAspectInstanceFactoryDecorator扩展Object实现可序列化
  - 序列化字段
    - maaif
```
MetadataAwareAspectInstanceFactory maaif
```
    - materialized
```
Object materialized
```
- 类org.springframework.aop.aspectj.annotation.NotAnAtAspectException扩展AopConfigException实现可序列化
  - 序列化字段
    - nonAspectClass
```
Class<T> nonAspectClass
```
- 类org.springframework.aop.aspectj.annotation.PrototypeAspectInstanceFactory扩展BeanFactoryAspectInstanceFactory实现可序列化
- 类org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory扩展AbstractAspectJAdvisorFactory实现可序列化
  - 序列化字段
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
- 类org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor扩展DefaultPointcutAdvisor实现可序列化
- 类org.springframework.aop.aspectj.annotation.SingletonMetadataAwareAspectInstanceFactory扩展SingletonAspectInstanceFactory实现可序列化
  - 序列化字段
    - metadata
```
AspectMetadata metadata
```
程序包 org.springframework.aop.aspectj.autoproxy
- 类org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator扩展AbstractAdvisorAutoProxyCreator实现可序列化
程序包 org.springframework.aop.framework
- 类org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor扩展ProxyProcessorSupport实现可序列化
  - 序列化字段
    - advisor
```
Advisor advisor
```
    - beforeExistingAdvisors
```
boolean beforeExistingAdvisors
```
    - eligibleBeans
```
Map<K,V> eligibleBeans
```
- 类org.springframework.aop.framework.AbstractSingletonProxyFactoryBean扩展ProxyConfig实现可序列化
  - 序列化字段
    - target
```
Object target
```
    - proxyInterfaces
```
Class<T>[] proxyInterfaces
```
    - preInterceptors
```
Object[] preInterceptors
```
    - postInterceptors
```
Object[] postInterceptors
```
    - advisorAdapterRegistry
```
AdvisorAdapterRegistry advisorAdapterRegistry
```
      Default is global AdvisorAdapterRegistry
    - proxy
```
Object proxy
```
- 类org.springframework.aop.framework.AdvisedSupport扩展ProxyConfig实现可序列化
  
  serialVersionUID:
  
  2651364800145442165L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - targetSource
```
TargetSource targetSource
```
      Package-protected to allow direct access for efficiency
    - preFiltered
```
boolean preFiltered
```
      Whether the Advisors are already filtered for the specific target class
    - advisorChainFactory
```
AdvisorChainFactory advisorChainFactory
```
      The AdvisorChainFactory to use
    - interfaces
```
List<E> interfaces
```
      Interfaces to be implemented by the proxy. Held in List to keep the order of registration, to create JDK proxy with specified order of interfaces.
    - advisors
```
List<E> advisors
```
      List of Advisors. If an Advice is added, it will be wrapped in an Advisor before being added to this List.
    - advisorArray
```
Advisor[] advisorArray
```
      Array updated on changes to the advisors list, which is easier to manipulate internally.
- 类org.springframework.aop.framework.AopConfigException扩展org.springframework.core.NestedRuntimeException实现可序列化
- 类org.springframework.aop.framework.CglibAopProxy.SerializableNoOp扩展Object实现可序列化
- 类org.springframework.aop.framework.DefaultAdvisorChainFactory扩展Object实现可序列化
- 类org.springframework.aop.framework.DefaultAopProxyFactory扩展Object实现可序列化
- 类org.springframework.aop.framework.ProxyConfig扩展Object实现可序列化
  
  serialVersionUID:
  
  -8409359707199703185L
  - 序列化字段
    - proxyTargetClass
```
boolean proxyTargetClass
```
    - optimize
```
boolean optimize
```
    - opaque
```
boolean opaque
```
    - exposeProxy
```
boolean exposeProxy
```
    - frozen
```
boolean frozen
```
- 类org.springframework.aop.framework.ProxyCreatorSupport扩展AdvisedSupport实现可序列化
  - 序列化字段
    - aopProxyFactory
```
AopProxyFactory aopProxyFactory
```
    - listeners
```
List<E> listeners
```
    - active
```
boolean active
```
      Set to true when the first AOP proxy has been created
- 类org.springframework.aop.framework.ProxyFactory扩展ProxyCreatorSupport实现可序列化
- 类org.springframework.aop.framework.ProxyFactoryBean扩展ProxyCreatorSupport实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - logger
```
Log logger
```
    - interceptorNames
```
String[] interceptorNames
```
    - targetName
```
String targetName
```
    - autodetectInterfaces
```
boolean autodetectInterfaces
```
    - singleton
```
boolean singleton
```
    - advisorAdapterRegistry
```
AdvisorAdapterRegistry advisorAdapterRegistry
```
    - freezeProxy
```
boolean freezeProxy
```
    - advisorChainInitialized
```
boolean advisorChainInitialized
```
      Whether the advisor chain has already been initialized
    - singletonInstance
```
Object singletonInstance
```
      If this is a singleton, the cached singleton proxy instance
- 类org.springframework.aop.framework.ProxyProcessorSupport扩展ProxyConfig实现可序列化
  - 序列化字段
    - order
```
int order
```
      This should run after all other processors, so that it can just add an advisor to existing proxies rather than double-proxy.
    - proxyClassLoader
```
ClassLoader proxyClassLoader
```
    - classLoaderConfigured
```
boolean classLoaderConfigured
```
程序包 org.springframework.aop.framework.adapter
- 类org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor扩展Object实现可序列化
  - 序列化字段
    - advice
```
AfterReturningAdvice advice
```
- 类org.springframework.aop.framework.adapter.DefaultAdvisorAdapterRegistry扩展Object实现可序列化
  - 序列化字段
    - adapters
```
List<E> adapters
```
- 类org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor扩展Object实现可序列化
  - 序列化字段
    - advice
```
MethodBeforeAdvice advice
```
- 类org.springframework.aop.framework.adapter.UnknownAdviceTypeException扩展IllegalArgumentException实现可序列化
程序包 org.springframework.aop.framework.autoproxy
- 类org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator扩展AbstractAutoProxyCreator实现可序列化
  - 序列化字段
    - advisorRetrievalHelper
```
BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper
```
- 类org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator扩展ProxyProcessorSupport实现可序列化
  - 序列化字段
    - logger
```
Log logger
```
      Logger available to subclasses
    - advisorAdapterRegistry
```
AdvisorAdapterRegistry advisorAdapterRegistry
```
      Default is global AdvisorAdapterRegistry
    - freezeProxy
```
boolean freezeProxy
```
      Indicates whether or not the proxy should be frozen. Overridden from super to prevent the configuration from becoming frozen too early.
    - interceptorNames
```
String[] interceptorNames
```
      Default is no common interceptors
    - applyCommonInterceptorsFirst
```
boolean applyCommonInterceptorsFirst
```
    - customTargetSourceCreators
```
TargetSourceCreator[] customTargetSourceCreators
```
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
    - targetSourcedBeans
```
Set<E> targetSourcedBeans
```
    - earlyProxyReferences
```
Map<K,V> earlyProxyReferences
```
    - proxyTypes
```
Map<K,V> proxyTypes
```
    - advisedBeans
```
Map<K,V> advisedBeans
```
- 类org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor扩展AbstractAdvisingBeanPostProcessor实现可序列化
  - 序列化字段
    - beanFactory
```
org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory
```
- 类org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator扩展AbstractAutoProxyCreator实现可序列化
  - 序列化字段
    - beanNames
```
List<E> beanNames
```
- 类org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator扩展AbstractAdvisorAutoProxyCreator实现可序列化
  - 序列化字段
    - usePrefix
```
boolean usePrefix
```
    - advisorBeanNamePrefix
```
String advisorBeanNamePrefix
```
- 类org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator扩展AbstractAdvisorAutoProxyCreator实现可序列化
  - 序列化字段
    - beanFactory
```
org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory
```
程序包 org.springframework.aop.interceptor
- 类org.springframework.aop.interceptor.AbstractMonitoringInterceptor扩展AbstractTraceInterceptor实现可序列化
  - 序列化字段
    - prefix
```
String prefix
```
    - suffix
```
String suffix
```
    - logTargetClassInvocation
```
boolean logTargetClassInvocation
```
- 类org.springframework.aop.interceptor.AbstractTraceInterceptor扩展Object实现可序列化
  - 序列化字段
    - hideProxyClassNames
```
boolean hideProxyClassNames
```
      Indicates whether or not proxy class names should be hidden when using dynamic loggers.
      
      另请参阅:
      
      AbstractTraceInterceptor.setUseDynamicLogger(boolean)
    - logExceptionStackTrace
```
boolean logExceptionStackTrace
```
      Indicates whether to pass an exception to the logger.
      
      另请参阅:
      
      AbstractTraceInterceptor.writeToLog(Log, String, Throwable)
- 类org.springframework.aop.interceptor.ConcurrencyThrottleInterceptor扩展org.springframework.util.ConcurrencyThrottleSupport实现可序列化
- 类org.springframework.aop.interceptor.CustomizableTraceInterceptor扩展AbstractTraceInterceptor实现可序列化
  - 序列化字段
    - enterMessage
```
String enterMessage
```
      The message for method entry.
    - exitMessage
```
String exitMessage
```
      The message for method exit.
    - exceptionMessage
```
String exceptionMessage
```
      The message for exceptions during method execution.
- 类org.springframework.aop.interceptor.DebugInterceptor扩展SimpleTraceInterceptor实现可序列化
  - 序列化字段
    - count
```
long count
```
- 类org.springframework.aop.interceptor.ExposeInvocationInterceptor扩展Object实现可序列化
  - 序列化方法
    - readResolve
```
private Object readResolve()
```
      Required to support serialization. Replaces with canonical instance on deserialization, protecting Singleton pattern.
      Alternative to overriding the equals method.
- 类org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor扩展AbstractMonitoringInterceptor实现可序列化
  - 序列化字段
    - trackAllInvocations
```
boolean trackAllInvocations
```
- 类org.springframework.aop.interceptor.PerformanceMonitorInterceptor扩展AbstractMonitoringInterceptor实现可序列化
- 类org.springframework.aop.interceptor.SimpleTraceInterceptor扩展AbstractTraceInterceptor实现可序列化
程序包 org.springframework.aop.scope
- 类org.springframework.aop.scope.DefaultScopedObject扩展Object实现可序列化
  - 序列化字段
    - beanFactory
```
org.springframework.beans.factory.config.ConfigurableBeanFactory beanFactory
```
    - targetBeanName
```
String targetBeanName
```
- 类org.springframework.aop.scope.ScopedProxyFactoryBean扩展ProxyConfig实现可序列化
  - 序列化字段
    - scopedTargetSource
```
SimpleBeanTargetSource scopedTargetSource
```
      The TargetSource that manages scoping
    - targetBeanName
```
String targetBeanName
```
      The name of the target bean
    - proxy
```
Object proxy
```
      The cached singleton proxy
程序包 org.springframework.aop.support
- 类org.springframework.aop.support.AbstractBeanFactoryPointcutAdvisor扩展AbstractPointcutAdvisor实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - adviceBeanName
```
String adviceBeanName
```
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
- 类org.springframework.aop.support.AbstractExpressionPointcut扩展Object实现可序列化
  - 序列化字段
    - location
```
String location
```
    - expression
```
String expression
```
- 类org.springframework.aop.support.AbstractGenericPointcutAdvisor扩展AbstractPointcutAdvisor实现可序列化
  - 序列化字段
    - advice
```
Advice advice
```
- 类org.springframework.aop.support.AbstractPointcutAdvisor扩展Object实现可序列化
  - 序列化字段
    - order
```
Integer order
```
- 类org.springframework.aop.support.AbstractRegexpMethodPointcut扩展StaticMethodMatcherPointcut实现可序列化
  - 序列化字段
    - patterns
```
String[] patterns
```
      Regular expressions to match.
    - excludedPatterns
```
String[] excludedPatterns
```
      Regular expressions not to match.
- 类org.springframework.aop.support.ComposablePointcut扩展Object实现可序列化
  
  serialVersionUID:
  
  -2743223737633663832L
  - 序列化字段
    - classFilter
```
ClassFilter classFilter
```
    - methodMatcher
```
MethodMatcher methodMatcher
```
- 类org.springframework.aop.support.ControlFlowPointcut扩展Object实现可序列化
  - 序列化字段
    - clazz
```
Class<T> clazz
```
    - methodName
```
String methodName
```
    - evaluations
```
int evaluations
```
- 类org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor扩展AbstractBeanFactoryPointcutAdvisor实现可序列化
  - 序列化字段
    - pointcut
```
Pointcut pointcut
```
- 类org.springframework.aop.support.DefaultIntroductionAdvisor扩展Object实现可序列化
  - 序列化字段
    - advice
```
Advice advice
```
    - interfaces
```
Set<E> interfaces
```
    - order
```
int order
```
- 类org.springframework.aop.support.DefaultPointcutAdvisor扩展AbstractGenericPointcutAdvisor实现可序列化
  - 序列化字段
    - pointcut
```
Pointcut pointcut
```
- 类org.springframework.aop.support.DelegatePerTargetObjectIntroductionInterceptor扩展IntroductionInfoSupport实现可序列化
  - 序列化字段
    - delegateMap
```
Map<K,V> delegateMap
```
      Hold weak references to keys as we don't want to interfere with garbage collection..
    - defaultImplType
```
Class<T> defaultImplType
```
    - interfaceType
```
Class<T> interfaceType
```
- 类org.springframework.aop.support.DelegatingIntroductionInterceptor扩展IntroductionInfoSupport实现可序列化
  - 序列化字段
    - delegate
```
Object delegate
```
      Object that actually implements the interfaces. May be "this" if a subclass implements the introduced interfaces.
- 类org.springframework.aop.support.IntroductionInfoSupport扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      This method is implemented only to restore the logger. We don't make the logger static as that would mean that subclasses would use this class's log category.
      
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - publishedInterfaces
```
Set<E> publishedInterfaces
```
- 类org.springframework.aop.support.JdkRegexpMethodPointcut扩展AbstractRegexpMethodPointcut实现可序列化
  - 序列化字段
    - compiledPatterns
```
Pattern[] compiledPatterns
```
      Compiled form of the patterns.
    - compiledExclusionPatterns
```
Pattern[] compiledExclusionPatterns
```
      Compiled form of the exclusion patterns.
- 类org.springframework.aop.support.NameMatchMethodPointcut扩展StaticMethodMatcherPointcut实现可序列化
  - 序列化字段
    - mappedNames
```
List<E> mappedNames
```
- 类org.springframework.aop.support.NameMatchMethodPointcutAdvisor扩展AbstractGenericPointcutAdvisor实现可序列化
  - 序列化字段
    - pointcut
```
NameMatchMethodPointcut pointcut
```
- 类org.springframework.aop.support.RegexpMethodPointcutAdvisor扩展AbstractGenericPointcutAdvisor实现可序列化
  - 序列化字段
    - patterns
```
String[] patterns
```
    - pointcut
```
AbstractRegexpMethodPointcut pointcut
```
    - pointcutMonitor
```
Object pointcutMonitor
```
- 类org.springframework.aop.support.RootClassFilter扩展Object实现可序列化
  - 序列化字段
    - clazz
```
Class<T> clazz
```
- 类org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor扩展StaticMethodMatcherPointcut实现可序列化
  - 序列化字段
    - advice
```
Advice advice
```
    - order
```
int order
```
程序包 org.springframework.aop.target
- 类org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource扩展Object实现可序列化
  
  serialVersionUID:
  
  -4721607536018568393L
  - 序列化字段
    - logger
```
Log logger
```
      Logger available to subclasses
    - targetBeanName
```
String targetBeanName
```
      Name of the target bean we will create on each invocation
    - targetClass
```
Class<T> targetClass
```
      Class of the target
    - beanFactory
```
org.springframework.beans.factory.BeanFactory beanFactory
```
      BeanFactory that owns this TargetSource. We need to hold onto this reference so that we can create new prototype instances as necessary.
- 类org.springframework.aop.target.AbstractPoolingTargetSource扩展AbstractPrototypeBasedTargetSource实现可序列化
  - 序列化字段
    - maxSize
```
int maxSize
```
      The maximum size of the pool
- 类org.springframework.aop.target.AbstractPrototypeBasedTargetSource扩展AbstractBeanFactoryBasedTargetSource实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      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.
      
      抛出:
      
      ObjectStreamException
- 类org.springframework.aop.target.CommonsPool2TargetSource扩展AbstractPoolingTargetSource实现可序列化
  - 序列化字段
    - maxIdle
```
int maxIdle
```
    - minIdle
```
int minIdle
```
    - maxWait
```
long maxWait
```
    - timeBetweenEvictionRunsMillis
```
long timeBetweenEvictionRunsMillis
```
    - minEvictableIdleTimeMillis
```
long minEvictableIdleTimeMillis
```
    - blockWhenExhausted
```
boolean blockWhenExhausted
```
    - pool
```
org.apache.commons.pool2.ObjectPool<T> pool
```
      The Apache Commons ObjectPool used to pool target objects
- 类org.springframework.aop.target.EmptyTargetSource扩展Object实现可序列化
  
  serialVersionUID:
  
  3680494563553489691L
  - 序列化方法
    - readResolve
```
private Object readResolve()
```
      Returns the canonical instance on deserialization in case of no target class, thus protecting the Singleton pattern.
  - 序列化字段
    - targetClass
```
Class<T> targetClass
```
    - isStatic
```
boolean isStatic
```
- 类org.springframework.aop.target.HotSwappableTargetSource扩展Object实现可序列化
  
  serialVersionUID:
  
  7497929212653839187L
  - 序列化字段
    - target
```
Object target
```
      The current target object
- 类org.springframework.aop.target.LazyInitTargetSource扩展AbstractBeanFactoryBasedTargetSource实现可序列化
  - 序列化字段
    - target
```
Object target
```
- 类org.springframework.aop.target.PrototypeTargetSource扩展AbstractPrototypeBasedTargetSource实现可序列化
- 类org.springframework.aop.target.SimpleBeanTargetSource扩展AbstractBeanFactoryBasedTargetSource实现可序列化
- 类org.springframework.aop.target.SingletonTargetSource扩展Object实现可序列化
  
  serialVersionUID:
  
  9031246629662423738L
  - 序列化字段
    - target
```
Object target
```
      Target cached and invoked using reflection
- 类org.springframework.aop.target.ThreadLocalTargetSource扩展AbstractPrototypeBasedTargetSource实现可序列化
  - 序列化字段
    - targetInThread
```
ThreadLocal<T> targetInThread
```
      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.
    - targetSet
```
Set<E> targetSet
```
      Set of managed targets, enabling us to keep track of the targets we've created.
    - invocationCount
```
int invocationCount
```
    - hitCount
```
int hitCount
```

序列化表格

程序包 org.aopalliance.aop

类org.aopalliance.aop.AspectException扩展RuntimeException实现可序列化

程序包 org.springframework.aop

类org.springframework.aop.AopInvocationException扩展org.springframework.core.NestedRuntimeException实现可序列化

程序包 org.springframework.aop.aspectj

类org.springframework.aop.aspectj.AbstractAspectJAdvice扩展Object实现可序列化

序列化方法

readObject

序列化字段

declaringClass

methodName

parameterTypes

pointcut

aspectInstanceFactory

aspectName

declarationOrder

argumentNames

throwingName

returningName

discoveredReturningType

discoveredThrowingType

joinPointArgumentIndex

joinPointStaticPartArgumentIndex

argumentBindings

argumentsIntrospected

discoveredReturningGenericType

类org.springframework.aop.aspectj.AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException扩展RuntimeException实现可序列化

类org.springframework.aop.aspectj.AspectJAfterAdvice扩展AbstractAspectJAdvice实现可序列化

类org.springframework.aop.aspectj.AspectJAfterReturningAdvice扩展AbstractAspectJAdvice实现可序列化

类org.springframework.aop.aspectj.AspectJAfterThrowingAdvice扩展AbstractAspectJAdvice实现可序列化

类org.springframework.aop.aspectj.AspectJAroundAdvice扩展AbstractAspectJAdvice实现可序列化

类org.springframework.aop.aspectj.AspectJExpressionPointcut扩展AbstractExpressionPointcut实现可序列化

序列化方法

readObject

序列化字段

pointcutDeclarationScope

pointcutParameterNames

pointcutParameterTypes

beanFactory

类org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor扩展AbstractGenericPointcutAdvisor实现可序列化

序列化字段

pointcut

类org.springframework.aop.aspectj.AspectJMethodBeforeAdvice扩展AbstractAspectJAdvice实现可序列化

类org.springframework.aop.aspectj.SingletonAspectInstanceFactory扩展Object实现可序列化

序列化字段

aspectInstance

程序包 org.springframework.aop.aspectj.annotation

类org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator扩展AspectJAwareAdvisorAutoProxyCreator实现可序列化

序列化字段

includePatterns

aspectJAdvisorFactory

aspectJAdvisorsBuilder

类org.springframework.aop.aspectj.annotation.AspectJProxyFactory扩展ProxyCreatorSupport实现可序列化

序列化字段

aspectFactory

类org.springframework.aop.aspectj.annotation.AspectMetadata扩展Object实现可序列化

序列化方法

readObject

序列化字段

aspectName

aspectClass

perClausePointcut

类org.springframework.aop.aspectj.annotation.BeanFactoryAspectInstanceFactory扩展Object实现可序列化

序列化字段

beanFactory

name

aspectMetadata

类org.springframework.aop.aspectj.annotation.LazySingletonAspectInstanceFactoryDecorator扩展Object实现可序列化

序列化字段

maaif

materialized

类org.springframework.aop.aspectj.annotation.NotAnAtAspectException扩展AopConfigException实现可序列化

序列化字段

nonAspectClass

类org.springframework.aop.aspectj.annotation.PrototypeAspectInstanceFactory扩展BeanFactoryAspectInstanceFactory实现可序列化

类org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory扩展AbstractAspectJAdvisorFactory实现可序列化

序列化字段

beanFactory

类org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor扩展DefaultPointcutAdvisor实现可序列化