出问题的配置

//配置1
<bean class="org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator">
  <property name="proxyTargetClass" value="true"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>

此配置的目的是想进行cglib类代理。但是实际上当进行直接注入类，而不是接口时会找不到Bean错误。

但是如果是这样配置：

//配置2
<aop:aspectj-autoproxy proxy-target-class="true"/>
<tx:annotation-driven transaction-manager="transactionManager"/>

此配置可以很好的工作，并注入类（不是接口）。

分析

1、<aop:aspectj-autoproxy proxy-target-class="true"> 该命名空间会交给org.springframework.aop.config.AopNamespaceHandler处理：

registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());

在AspectJAutoProxyBeanDefinitionParser中，会执行parse方法解析配置：

public BeanDefinition parse(Element element, ParserContext parserContext) {
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    extendBeanDefinition(element, parserContext);
    return null;
}

其中AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);目的是注册AnnotationAwareAspectJAutoProxyCreator：

return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);

但是注意了：

if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
  BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
  if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
    int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
    int requiredPriority = findPriorityForClass(cls);
    if (currentPriority < requiredPriority) {
      apcDefinition.setBeanClassName(cls.getName());
    }
  }
  return null;
}

大家可以看到一句话：

if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME))
AUTO_PROXY_CREATOR_BEAN_NAME=“org.springframework.aop.config.internalAutoProxyCreator”，
即首先判断当前容器中是否包含名字为AUTO_PROXY_CREATOR_BEAN_NAME的Bean，如果包含：然后判断优先级，谁优先级高谁获胜，即最后那个获胜的是实际的AutoProxyCreator

到此我们可以看到跟"<bean class="org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator">"配置没什么区别，除了没有名字外。

2、接下来看一下<tx:annotation-driven>：

该命名空间交给org.springframework.transaction.config.TxNamespaceHandler处理：

registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());

其中<annotation-driven> 会交给AnnotationDrivenBeanDefinitionParser进行解析：

public BeanDefinition parse(Element element, ParserContext parserContext) {
  String mode = element.getAttribute("mode");
  if ("aspectj".equals(mode)) {
    // mode="aspectj"
    registerTransactionAspect(element, parserContext);
  }else {
    // mode="proxy"
    AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
  }
  return null;
}

默认mode="proxy"，所以走AopAutoProxyConfigurer.configureAutoProxyCreator，其代码中第一句话是：

AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

public static void registerAutoProxyCreatorIfNecessary(
                  ParserContext parserContext, Element sourceElement) {

  BeanDefinition beanDefinition = AopConfigUtils.registerAutoProxyCreatorIfNecessary(
    parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext);
 }

AopConfigUtils.registerAutoProxyCreatorIfNecessary是：

registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);

private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, Object source) {
  Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
    if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
      int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
      int requiredPriority = findPriorityForClass(cls);
      if (currentPriority < requiredPriority) {
        apcDefinition.setBeanClassName(cls.getName());
      }
    }
    return null;
  }
//省略

}

此处我们又看到了registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)，如果是：

配置1，那么实际是两个AutoProxyCreator。前面<bean class="org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator">定义了一个AutoProxyCreator，后面的<tx:annotation-driven transaction-manager="transactionManager"/>也定义另一个AutoProxyCreator。
配置2，那么实际是共用一个AutoProxyCreator；

而且如果配置1时，因为我们没有指定<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/> 所以是JDK动态代理，因此不管怎么样，都无法注入类的。

问题找到了，原因是注册了两个AutoProxyCreator，造成了二次代理引发的问题，这个和之前的《spring的bean二次代理问题》一样

如何解决

给配置1起名字为”org.springframework.aop.config.internalAutoProxyCreator“；
或者使用配置2

建议

1、如果没有必要，请不要使用低级别API，如上述-->自己去创建AutoProxyCreator
2、首先选择使用如：
<aop:config>或者是<org.springframework.aop.config.internalAutoProxyCreator>

如上配置已经非常好了，根本没必要使用低级别API。
如<tx:annotation-driven>使用的AutoProxyCreator都是和上边是一样的。这样还能防止二次代理。

声明式/@AspectJ风格的AOP都非常好了，完全没必要使用低级别API，请不要再使用低级别API了。

如何用过shiro的朋友都应该知道如下配置:

<!-- Enable Shiro Annotations for Spring-configured beans.  Only run after -->
<!-- the lifecycleBeanProcessor has run: -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
    <property name="securityManager" ref="securityManager"/>
</bean>

其实我们可以换成这样：

<aop:config proxy-target-class="true"/>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
  <property name="securityManager" ref="securityManager"/>
</bean>

或者使用<aop:aspectj-autoproxy>也行，这样也不会存在二次代理的问题。

至于shiro这个之前的配置容易发生二次注入，我会再下一篇文章《在springmvc+shiro项目中使用druid监听controller层出现IllegalStateException异常》详细讲到