一个经典的Spring IOC疑难症状释疑

Case
   请看下面的IOC实例：
  
   1）AaaService实现AaaaInterface接口
   2）在BaaService中Autowired AaaService
  
Code

//1.AaaInterface
package com.test;
public interface AaaInterface {
    void method1();
}

//2.AaaService
package com.test;
public class AaaService implements AaaInterface {

    @Override
    public void method1() {
        System.out.println("hello");
    }

    public void method2() {
        System.out.println("hello");
    }
}

//3.BbbService
package com.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
public class BbbService {

    @Autowired
    private AaaService aaaService;

    public void method2(){
        System.out.println("hello method2");
    }
}

Spring XML配置

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

    <context:property-placeholder location="classpath*:conf.properties"/>
    <!--扫描除Controller外的Bean,Controller在MVC层配置-->
    <context:component-scan base-package="com.test"/>

    <!--数据源-->
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.SingleConnectionDataSource"
          p:driverClassName="${jdbc.driverClassName}"
          p:url="${jdbc.url}"
          p:username="${jdbc.username}"
          p:password="${jdbc.password}"/>

    <bean id="txManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
          p:dataSource-ref="dataSource"/>

    <!-- 通过AOP配置的事务管理增强 -->
    <aop:config >
        <aop:pointcut id="serviceMethod"
                      expression="execution(public * com.test..*Service.*(..))"/>
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
    </aop:config>

    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <!-- //////////////////////////////////////////////// -->
</beans>

启动Spring容器

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainStarter {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        BbbService bbbService = applicationContext.getBean("bbbService", BbbService.class);
    }
}

结果报了以下这堆异常：

2013-7-25 13:54:08 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@687bc899: defining beans [org.springframework.context.support.PropertySourcesPlaceholderConfigurer#0,aaaService,bbbService,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,dataSource,txManager,org.springframework.aop.config.internalAutoProxyCreator,serviceMethod,org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor#0,txAdvice,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
//重要的信息在这儿！！
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'bbbService': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.test.AaaService com.test.BbbService.aaaService; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.test.AaaService] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:288)
	at 
	... 50 more

上面的异常告诉我们，BbbService Bean创建不了，因为无法Autowired其aaaService的成员变量，说在Spring容器中不存在这个AaaService的Bean.

分析

以上是Spring IoC中一个经典的错误，其原因是Spring对Bean的动态代理引起的：

1)由于在applicationContext.xml中，通过<aop>对所有Service进行事务增强，因此Spring容器会对所有所有XxxService的Bean进行动态代理；

2)默认情况下，Spring使用基于接口的代理，也即：
  a)如果Bean类有实现接口，那么Spring自动使用基于接口的代理创建该Bean的代理实例；
  b)如果Bean类没有实现接口，那么则使用基于子类扩展的动态代理（即CGLib代理）；

3）由于我们的AaaService实现了AaaInterface，所以Spring在生成AaaService类的动态代理Bean时，采用了
  基于接口的动态代理，该动态代理实例只实现AaaInterface，且该实例不能强制转换成AaaService。换句话说，AaaService生成的Bean不能赋给AaaService的实例，而只能赋给AaaInterface的实例。

4)因此，当BbbService希望注入AaaService的成员时，Spring找不到对应的Bean了（因为只有AaaInterface的Bean）.


解决


方法1

既然AaaService Bean是被Spring动态代理后改变成了类型，那如果取消引起动态代理的配置，使Spring不会对AaaService动态代理，那么AaaService的Bean类型就是原始的AaaService了：

<beans>
...
    <!-- 把以下的配置注释掉 -->
 <!--    <aop:config >
        <aop:pointcut id="serviceMethod"
                      expression="execution(public * com.test..*Service.*(..))"/>
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
    </aop:config>

    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>-->
    <!-- //////////////////////////////////////////////// -->
</beans>

引起Spring对AaaService进行动态代理的<aop>配置注释后，重新启动容器，即可正常启动了。

但是这里AaaService的方法就不会被事务增强了，这将违背了我们的初衷，因此这种解决方法仅是为了让大家了解到引起IOC问题的根源所在，并没有真正解决问题。

方法2

将BbbService的AaaService成员改成AaaInterface：

@Service("bbbService")
public class BbbService {

    @Autowired
    private AaaInterface aaaService;//注意这儿，成员类型从AaaService更改为AaaInterface

    public void method2(){
        System.out.println("hello method2");
    }
}

既然AaaService Bean被植入事务增强动态代理后就变成了AaaInterface的实例，那么干脆我们更改BbbService的成员属性类型，也是可以解决问题的。

但是这样的话，只能调用接口中拥有的方法 ，在AaaService中定义的方法（如method2())就调用不到了，因为这个代理后的Bean不能被强制转换成AaaService。

因此，就引出了我们的终极解决办法，请看方法3：

方法3

  刚才我们说“Spring在默认情况下，对实现接口的Bean采用基于接口的代理”，我们可否改变Spring这一“默认的行为”呢？答案是肯定的，那就是通过proxy-target-class="true"这个属性，Spring植入增强时，将不管Bean有没有实现接口，统统采用基于扩展子类的方式进行动态代理，也即生成的动态代理是AaaService的子类，那当然就可以赋给AaaService有实例了：

    <!-- 注意这儿的proxy-target-class="true" -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="serviceMethod"
                      expression="execution(public * com.test..*Service.*(..))"/>
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
    </aop:config>

    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

注意，你需要将CGLib包放到类路径下，因为Spring用它来动态生成代理！以下是我这个小例子的Maven:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>onlyTest</groupId>
    <artifactId>onlyTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
       <spring.version>3.2.3.RELEASE</spring.version>
        <mysql.version>5.1.25</mysql.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.10</version>
        </dependency>

    </dependencies>
    
</project>

这个是常见问题了，以前碰到过，debug源码搞了好久才搞明白。proxy-target-class="true"这个选项是关键。所以我对这个AOP的实现印象非常差。以至于我通常一直在用BeanNameAutoProxyCreator，简单可靠，还不会受到各种额外因素的困扰，还可以配置除了事物以外其他的拦截器。

	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
         <property name="transactionManager" ref="transactionManager" />
         <property name="transactionAttributes">
              <props>
                   <prop key="*">PROPAGATION_REQUIRED</prop>
              </props>
         </property>
    </bean>

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
         <property name="beanNames">
              <list>
                   <value>*Service</value>
              </list>
         </property>
         <property name="interceptorNames">
              <list>
                   <value>transactionInterceptor</value>
              </list>
         </property>
     </bean>

哈 你这是1.0的实现，配置太复杂了。不过，可以对原有实现比较清楚，通过<aop>的层层封装，很多东西变得云遮雾轩罩了。

Spring 根本就是鼓勵針對接口編程的，這在我看來，怎麼感覺是你接口設計的問題呢

动态代理，必须是接口类型，程序无法自动相下强转

楼主认真！学习了！

如果凡是都一定要定义接口，就有点八股了。象一般的企业应用，Service直接用类可能比先定义接口再实现更便捷。

这句话有问题，动态代理有两种实现技术，其一是基于JDK的接口的动态代理，其二是基于JVM中动态更改字节码的动态代理。

面向接口编程
像LZ这种使用具体实现类来解决问题 完全就是偏离了使用spring的目的 所以我觉得这不是spring的bug 更不需要什么修正的方案。