【Spring源码分析】18-CommonAnnotationBeanPostProcessor

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

CommonAnnotationBeanPostProcessor这个BeanPostProcessor通过继承InitDestroyAnnotationBeanPostProcessor对@javax.annotation.PostConstruct和@javax.annotation.PreDestroy注解的支持。以及依据bean name依赖注入的@javax.annotation.Resource支持。也支持WebServiceRef注解,具有创建JAX-WS服务端点的能力。最后,处理器还支持EJB3(@EJB)。

1、对@PostConstruct和@PreDestroy注解的处理

CommonAnnotationBeanPostProcessor继承了InitDestroyAnnotationBeanPostProcessor,这两个注解是由这个父类完成解析的,在CommonAnnotationBeanPostProcessor构造函数中调用父类的方法setInitAnnotationType()和setDestroyAnnotationType()将这两个注解Class对象传递给父类。

    public CommonAnnotationBeanPostProcessor() {
       setOrder(Ordered.LOWEST_PRECEDENCE - 3);
       setInitAnnotationType(PostConstruct.class);
       setDestroyAnnotationType(PreDestroy.class);
       ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

在InitDestroyAnnotationBeanPostProcessor中分三个阶段完成这两个注解功能,分别为:

  1. 实现了MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法缓存初始化后和销毁前执行的方法。
  2. 实现了BeanPostProcessor.postProcessBeforeInitialization()用来执行@PostConstruct标注的方法。
  3. 实现了DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()用来执行@PreDestroy标注的方法。

1.1、在实例化一个bean后此时还未进行依赖注入时,每个bean definition会被MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法执行一遍用来获取一些元数据来增加额外的功能,InitDestroyAnnotationBeanPostProcessor就是将bean定义了被@PostConstruct和@PreDestroy注解的方法缓存到一个Map中,供之后BeanPostProcessor.postProcessBeforeInitialization()和DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()阶段可以直接获取这些方法来执行。

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
       LifecycleMetadata metadata = findLifecycleMetadata(beanType);
       metadata.checkConfigMembers(beanDefinition);
    }
    private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
       if (this.lifecycleMetadataCache == null) {
          // Happens after deserialization, during destruction...
          return buildLifecycleMetadata(clazz);
       }
       // Quick check on the concurrent map first, with minimal locking.
       LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
       if (metadata == null) {
          synchronized (this.lifecycleMetadataCache) {
             metadata = this.lifecycleMetadataCache.get(clazz);
             if (metadata == null) {
                metadata = buildLifecycleMetadata(clazz);
                this.lifecycleMetadataCache.put(clazz, metadata);
             }
             return metadata;
          }
       }
       return metadata;
    }
    private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
       List<LifecycleElement> initMethods = new ArrayList<>();
       List<LifecycleElement> destroyMethods = new ArrayList<>();
       Class<?> targetClass = clazz;

       do {
          final List<LifecycleElement> currInitMethods = new ArrayList<>();
          final List<LifecycleElement> currDestroyMethods = new ArrayList<>();

          ReflectionUtils.doWithLocalMethods(targetClass, method -> {
             if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
                LifecycleElement element = new LifecycleElement(method);
                currInitMethods.add(element);
                if (logger.isTraceEnabled()) {
                   logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
                }
             }
             if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
                currDestroyMethods.add(new LifecycleElement(method));
                if (logger.isTraceEnabled()) {
                   logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
                }
             }
          });

          initMethods.addAll(0, currInitMethods);
          destroyMethods.addAll(currDestroyMethods);
          targetClass = targetClass.getSuperclass();
       }
       while (targetClass != null && targetClass != Object.class);

       return new LifecycleMetadata(clazz, initMethods, destroyMethods);
    }
    可以看到父类的方法会在子类方法前插入,所以方法的执行也是先父后子。

LifecycleElement是一个内部类,保存了方法和方法的一个标识,和一个invoke()方法用来调用被注解的方法。值得注意的是这个方法的可以是private的。

    private static class LifecycleElement {
       private final Method method;
       private final String identifier;
       public LifecycleElement(Method method) {
          if (method.getParameterCount() != 0) {
             throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
          }
          this.method = method;
          this.identifier = (Modifier.isPrivate(method.getModifiers()) ?
                ClassUtils.getQualifiedMethodName(method) : method.getName());
       }
       public void invoke(Object target) throws Throwable {
          ReflectionUtils.makeAccessible(this.method);
          this.method.invoke(target, (Object[]) null);
       }
    }

1.2、bean会经过BeanPostProcessor.postProcessBeforeInitialization()方法处理,这个时候就会调用@PostConstruct方法。

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
       try {
          metadata.invokeInitMethods(bean, beanName);
       }
       catch (InvocationTargetException ex) {
          throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
       }
       catch (Throwable ex) {
          throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
       }
       return bean;
    }
    public void invokeInitMethods(Object target, String beanName) throws Throwable {
       Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
       Collection<LifecycleElement> initMethodsToIterate =
             (checkedInitMethods != null ? checkedInitMethods : this.initMethods);
       if (!initMethodsToIterate.isEmpty()) {
          for (LifecycleElement element : initMethodsToIterate) {
             if (logger.isTraceEnabled()) {
                logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
             }
             element.invoke(target);
          }
       }
    }

1.3、在bean销毁前会经过DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()方法,在这个时候执行@PreDestroy方法。

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
       LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
       try {
          metadata.invokeDestroyMethods(bean, beanName);
       }
       catch (InvocationTargetException ex) {
          String msg = "Destroy method on bean with name '" + beanName + "' threw an exception";
          if (logger.isDebugEnabled()) {
             logger.warn(msg, ex.getTargetException());
          }
          else {
             logger.warn(msg + ": " + ex.getTargetException());
          }
       }
       catch (Throwable ex) {
          logger.warn("Failed to invoke destroy method on bean with name '" + beanName + "'", ex);
       }
    }
    public void invokeDestroyMethods(Object target, String beanName) throws Throwable {
       Collection<LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
       Collection<LifecycleElement> destroyMethodsToUse =
             (checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods);
       if (!destroyMethodsToUse.isEmpty()) {
          for (LifecycleElement element : destroyMethodsToUse) {
             if (logger.isTraceEnabled()) {
                logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
             }
             element.invoke(target);
          }
       }
    }

2、对@Resource注解的处理

与@PostConstruct类似,先在postProcessMergedBeanDefinition中取得被@Resource标记的字段或方法,后再postProcessProperties()方法中完成对象的注入。

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
       super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
       //找出beanType所有被@Resource标记的字段和方法封装到InjectionMetadata中
       InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
       //将InjectionMetadata中每个被@Resource标记的字段和方法打标,防止重复计算
       metadata.checkConfigMembers(beanDefinition);
    }

    private InjectionMetadata findResourceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
       // Fall back to class name as cache key, for backwards compatibility with custom callers.
       String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
       // Quick check on the concurrent map first, with minimal locking.
       InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
       if (InjectionMetadata.needsRefresh(metadata, clazz)) {
          synchronized (this.injectionMetadataCache) {
             metadata = this.injectionMetadataCache.get(cacheKey);
             if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                if (metadata != null) {
                   metadata.clear(pvs);
                }
                metadata = buildResourceMetadata(clazz);
                this.injectionMetadataCache.put(cacheKey, metadata);
             }
          }
       }
       return metadata;
    }
    private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
       List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
       Class<?> targetClass = clazz;

       do {
          final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

          ReflectionUtils.doWithLocalFields(targetClass, field -> {
             if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
                if (Modifier.isStatic(field.getModifiers())) {
                   throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields");
                }
                currElements.add(new WebServiceRefElement(field, field, null));
             }
             else if (ejbRefClass != null && field.isAnnotationPresent(ejbRefClass)) {
                if (Modifier.isStatic(field.getModifiers())) {
                   throw new IllegalStateException("@EJB annotation is not supported on static fields");
                }
                currElements.add(new EjbRefElement(field, field, null));
             }
             else if (field.isAnnotationPresent(Resource.class)) {
                //注意静态字段不支持
                if (Modifier.isStatic(field.getModifiers())) {
                   throw new IllegalStateException("@Resource annotation is not supported on static fields");
                }
                //如果不想注入某一类型对象 可以将其加入ignoredResourceTypes中
                if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
                   //字段会封装到ResourceElement
                   currElements.add(new ResourceElement(field, field, null));
                }
             }
          });

          ReflectionUtils.doWithLocalMethods(targetClass, method -> {
             //找出我们在代码中定义的方法而非编译器为我们生成的方法
             Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
             if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                return;
             }
             //如果重写了父类的方法,则使用子类的
             if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
                   if (Modifier.isStatic(method.getModifiers())) {
                      throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
                   }
                   if (method.getParameterCount() != 1) {
                      throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: " + method);
                   }
                   PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                   currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
                }
                else if (ejbRefClass != null && bridgedMethod.isAnnotationPresent(ejbRefClass)) {
                   if (Modifier.isStatic(method.getModifiers())) {
                      throw new IllegalStateException("@EJB annotation is not supported on static methods");
                   }
                   if (method.getParameterCount() != 1) {
                      throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method);
                   }
                   PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                   currElements.add(new EjbRefElement(method, bridgedMethod, pd));
                }
                else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
                   //同样不支持静态方法
                   if (Modifier.isStatic(method.getModifiers())) {
                      throw new IllegalStateException("@Resource annotation is not supported on static methods");
                   }
                   Class<?>[] paramTypes = method.getParameterTypes();
                   if (paramTypes.length != 1) {
                      throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
                   }
                   if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
                      //bean的getter或setter
                      PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                      currElements.add(new ResourceElement(method, bridgedMethod, pd));
                   }
                }
             }
          });
          //先父后子
          elements.addAll(0, currElements);
          targetClass = targetClass.getSuperclass();
       }
       while (targetClass != null && targetClass != Object.class);

       return new InjectionMetadata(clazz, elements);
     

上述代码是将@Resource注解的字段和方法以bean name为key,InjectionMetadata为value封装一个Map中,在属性注入阶段取出InjectionMetadata通过反射为目标字段或方法设置@Resource name指定的bean。

下面看postProcessProperties()方法如何进行属性注入的。

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
       InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
       try {
          metadata.inject(bean, beanName, pvs);
       }
       catch (Throwable ex) {
          throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
       }
       return pvs;
    }

将缓存中的InjectionMetadata 取出调用它的inject方法。

    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
       Collection<InjectedElement> checkedElements = this.checkedElements;
       Collection<InjectedElement> elementsToIterate =
             (checkedElements != null ? checkedElements : this.injectedElements);
       if (!elementsToIterate.isEmpty()) {
          for (InjectedElement element : elementsToIterate) {
             if (logger.isTraceEnabled()) {
                logger.trace("Processing injected element of bean '" + beanName + "': " + element);
             }
             element.inject(target, beanName, pvs);
          }
       }
    }

依次调用之前保存的ResouceElement对象的inject方法。下面的重点就是放到了ResouceElement身上。

20191017100328\_1.png

    private class ResourceElement extends LookupElement {

       private final boolean lazyLookup;

       //根据上面分析有两种调用构造方法的情况
       //1、member是字段ae也是字段,pd==null
       //2、member是桥接方法(或原始方法)ae是原始方法,pd是原始方法的getter或setter
       public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
          super(member, pd);
          Resource resource = ae.getAnnotation(Resource.class);
          String resourceName = resource.name();
          Class<?> resourceType = resource.type();
          this.isDefaultName = !StringUtils.hasLength(resourceName);
          if (this.isDefaultName) {
             ///如果没有设置@Resource name属性就用字段名称作为bean name
             resourceName = this.member.getName();
             //如果member是setter方法方法 则取setXXX得XXX部分为bean name
             if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
                resourceName = Introspector.decapitalize(resourceName.substring(3));
             }
          }
          else if (embeddedValueResolver != null) {
             //如果设置了@Resource name的属性,则使用EmbeddedValueResolver对象先做一次SpringEL解析得到真正的bean name
             resourceName = embeddedValueResolver.resolveStringValue(resourceName);
          }
          if (Object.class != resourceType) {
             //确保字段或setter方法类型与resourceType一致
             checkResourceType(resourceType);
          }
          else {
             // No resource type specified... check field/method.
             resourceType = getResourceType();
          }
          this.name = (resourceName != null ? resourceName : "");
          this.lookupType = resourceType;
          String lookupValue = resource.lookup();
          //如果使用jndi查找的名字
          this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
          Lazy lazy = ae.getAnnotation(Lazy.class);
          //是否延迟注入
          this.lazyLookup = (lazy != null && lazy.value());
       }

       @Override
       protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
          //如果懒加载则使用一个代理对象,往下看
          return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
                getResource(this, requestingBeanName));
       }
    }

从上面CommonAnnotationBeanPostProcessor的postProcessProperties()方法可知,属性的注入是调用ResourceElement的inject()方法,ResourceElement本身没有这个方法而是调用父类InjectedElement的inject方法。

    protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
          throws Throwable {

       if (this.isField) {
          Field field = (Field) this.member;
          ReflectionUtils.makeAccessible(field);
          //如果是使用字段形式的注入,getResourceToInject由子类@ResourceElement实现,下面再看
          field.set(target, getResourceToInject(target, requestingBeanName));
       }
       else {
          //此步骤检测如果bean已经显示的设置一个对象依赖引用则跳过使用setter方法再次赋值。
          if (checkPropertySkipping(pvs)) {
             return;
          }
          try {
             Method method = (Method) this.member;
             //支持私有方法
             ReflectionUtils.makeAccessible(method);
             method.invoke(target, getResourceToInject(target, requestingBeanName));
          }
          catch (InvocationTargetException ex) {
             throw ex.getTargetException();
          }
       }
    }

可以看到需要注入对象的来源方法getResourceToInject(),上面已经看到如果懒加载则使用buildLazyResourceProxy()方法将返回一个代理对象,等到使用到这个代理对象的方法时才会调用getResource()返回requestingBeanName指定的bean。下面先看getResource()方法。

    protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
          throws NoSuchBeanDefinitionException {

       if (StringUtils.hasLength(element.mappedName)) {
          return this.jndiFactory.getBean(element.mappedName, element.lookupType);
       }
       if (this.alwaysUseJndiLookup) {
          return this.jndiFactory.getBean(element.name, element.lookupType);
       }
       if (this.resourceFactory == null) {
          throw new NoSuchBeanDefinitionException(element.lookupType,
                "No resource factory configured - specify the 'resourceFactory' property");
       }
       return autowireResource(this.resourceFactory, element, requestingBeanName);
    }

getResource()方法又直接调用了autowireResource()方法。

    protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
          throws NoSuchBeanDefinitionException {

       Object resource;
       Set<String> autowiredBeanNames;
       String name = element.name;

       if (this.fallbackToDefaultTypeMatch && element.isDefaultName &&
             factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) {
          //如果容器中还没有此bean,则会使用resolveDependency()方法将符合bean type的bean definetion调用一次getBean()从这些bean选出符合requestingBeanName的bean
          autowiredBeanNames = new LinkedHashSet<>();
          resource = ((AutowireCapableBeanFactory) factory).resolveDependency(
                element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null);
          if (resource == null) {
             throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
          }
       }
       else {
          //如果容器中有此bean则取出这个bean对象作为属性值
          resource = factory.getBean(name, element.lookupType);
          autowiredBeanNames = Collections.singleton(name);
       }

       if (factory instanceof ConfigurableBeanFactory) {
          ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
          for (String autowiredBeanName : autowiredBeanNames) {
             if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
                beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
             }
          }
       }

       return resource;
    }

下面再看需要懒加载的代理对象创建方法buildLazyResourceProxy()。

    protected Object buildLazyResourceProxy(final LookupElement element, final @Nullable String requestingBeanName) {
       TargetSource ts = new TargetSource() {
          @Override
          public Class<?> getTargetClass() {
             return element.lookupType;
          }
          @Override
          public boolean isStatic() {
             return false;
          }
          @Override
          public Object getTarget() {
             //这个方法里还是会调用getResource(),什么时候调用的getTarget()方法呢,往下看
             return getResource(element, requestingBeanName);
          }
          @Override
          public void releaseTarget(Object target) {
          }
       };
       //代理对象工厂
       ProxyFactory pf = new ProxyFactory();
       pf.setTargetSource(ts);
       if (element.lookupType.isInterface()) {
          pf.addInterface(element.lookupType);
       }
       ClassLoader classLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
             ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() : null);
       return pf.getProxy(classLoader);
    }

代理工厂首先将TargetSource对象赋值到自身的成员变量中,然后调用getProxy()创建代理对象。

    public Object getProxy(@Nullable ClassLoader classLoader) {
       return createAopProxy().getProxy(classLoader);
    }
    protected final synchronized AopProxy createAopProxy() {
       if (!this.active) {
          activate();
       }
       //getAopProxyFactory()默认返回DefaultAopProxyFactory
       return getAopProxyFactory().createAopProxy(this);
    }
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
       if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
          Class<?> targetClass = config.getTargetClass();
          if (targetClass == null) {
             throw new AopConfigException("TargetSource cannot determine target class: " +
                   "Either an interface or a target is required for proxy creation.");
          }
          if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
             return new JdkDynamicAopProxy(config);
          }
          return new ObjenesisCglibAopProxy(config);
       }
       else {
          return new JdkDynamicAopProxy(config);
       }
    }

最终是使用了AopProxy 的具体子类的getProxy()方法完成代理对象的创建。以JdkDynamicAopProxy为例。

    public Object getProxy(@Nullable ClassLoader classLoader) {
       if (logger.isTraceEnabled()) {
          logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
       }
       Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
       findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
       return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

使用了JDK的动态代理,自身也实现了InvocationHandler接口,来看invoke()实现。

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       MethodInvocation invocation;
       Object oldProxy = null;
       boolean setProxyContext = false;

       TargetSource targetSource = this.advised.targetSource;
       Object target = null;

       try {
          if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
             // The target does not implement the equals(Object) method itself.
             return equals(args[0]);
          }
          else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
             // The target does not implement the hashCode() method itself.
             return hashCode();
          }
          else if (method.getDeclaringClass() == DecoratingProxy.class) {
             // There is only getDecoratedClass() declared -> dispatch to proxy config.
             return AopProxyUtils.ultimateTargetClass(this.advised);
          }
          else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                method.getDeclaringClass().isAssignableFrom(Advised.class)) {
             // Service invocations on ProxyConfig with the proxy config...
             return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
          }

          Object retVal;

          if (this.advised.exposeProxy) {
             // Make invocation available if necessary.
             oldProxy = AopContext.setCurrentProxy(proxy);
             setProxyContext = true;
          }

          // Get as late as possible to minimize the time we "own" the target,
          // in case it comes from a pool.
          target = targetSource.getTarget();
          Class<?> targetClass = (target != null ? target.getClass() : null);

          // Get the interception chain for this method.
          List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

          // Check whether we have any advice. If we don't, we can fallback on direct
          // reflective invocation of the target, and avoid creating a MethodInvocation.
          if (chain.isEmpty()) {
             // We can skip creating a MethodInvocation: just invoke the target directly
             // Note that the final invoker must be an InvokerInterceptor so we know it does
             // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
             Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
             retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
          }
          else {
             // We need to create a method invocation...
             invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
             // Proceed to the joinpoint through the interceptor chain.
             retVal = invocation.proceed();
          }

          // Massage return value if necessary.
          Class<?> returnType = method.getReturnType();
          if (retVal != null && retVal == target &&
                returnType != Object.class && returnType.isInstance(proxy) &&
                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
             // Special case: it returned "this" and the return type of the method
             // is type-compatible. Note that we can't help if the target sets
             // a reference to itself in another returned object.
             retVal = proxy;
          }
          else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
             throw new AopInvocationException(
                   "Null return value from advice does not match primitive return type for: " + method);
          }
          return retVal;
       }
       finally {
          if (target != null && !targetSource.isStatic()) {
             // Must have come from TargetSource.
             targetSource.releaseTarget(target);
          }
          if (setProxyContext) {
             // Restore old proxy.
             AopContext.setCurrentProxy(oldProxy);
          }
       }
    }

这个方法大段代码是为了实现AOP,但还是会调用target = targetSource.getTarget();获取实际对象的,可以看到懒加载机制的代理对象只有调用其方法才会去容器中获取实际的bean。


来源:[]()

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » 【Spring源码分析】18-CommonAnnotationBeanPostProcessor

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏