spring-源码-ignoreDependencyInterface

前言

1. 首先这个方法是 ConfigurableListableBeanFactory 里面的，说的是：自动装配（autowiring）的时候忽略的接口，注意：是autowiring并不是 @Autowired
2. 最近看spring 源码的时候，看到一个方法，ignoreDependencyInterface，然后研究其作用的时候，了解到的概念
3. 其源码就是往 set集合里面添加了一个数据，那什么时候使用呢，就是在BY_TYPE 自动装配的时候使用.

public AbstractAutowireCapableBeanFactory() {
    super(); //父类是空的构造
 
    // 自动装配 的时候 忽略 实现了这些接口的类，
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
}

2. AbstractApplicationContext.prepareBeanFactory

//  删除了大量的代码... 
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 忽略自动装配的接口，
    // Spring 会通过其他方式来处理这些依赖。
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
}

• 源码

private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();
 
//
public void ignoreDependencyInterface(Class<?> ifc) {
    this.ignoredDependencyInterfaces.add(ifc);
}

自动装配-BY_TYPE

@ComponentScan
public class IgnoreDependencyInterfaceContext {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IgnoreDependencyInterfaceContext.class);
        IgnoreDependencyInterfaceBeanB bean = context.getBean(IgnoreDependencyInterfaceBeanB.class);
        System.out.println(bean.getBeanNameAware()); // 没有自动注入
        System.out.println(bean.getEnvironmentAware());
        System.out.println(bean.getEmbeddedValueResolverAware()); // 没有自动注入
        System.out.println(bean.getResourceLoaderAware());
        System.out.println(bean.getApplicationEventPublisherAware()); // 没有自动注入
        System.out.println(bean.getMessageSourceAware()); // 没有自动注入
        System.out.println(bean.getApplicationContextAware());
    }
}

• 配置类

开启自动装配，默认是不会开启的，且这个是一个 过时 的 属性…

需要定义 set 方法，如果没有 set 方法 是不会进行注入的

@Configuration
public class IgnoreDependencyInterfaceBeanA {

	// 默认是不进行装配的，我们开启装配根据类型来，
	// 这样spring就会自动去根据 set 方法区帮我们注入Bean 
    @Bean(autowire = Autowire.BY_TYPE)
    public IgnoreDependencyInterfaceBeanB getB() {
        return new IgnoreDependencyInterfaceBeanB();
    }
}

• Bean：定义 类，需要注意的是我这里并没使用@Autowired
• 需要说的是整个是通过 @Bean 注解将对象放入到容器中的，

public class IgnoreDependencyInterfaceBeanB {
	
    // ignoreDependencyInterface 添加的接口
    private BeanNameAware beanNameAware;
    private BeanFactoryAware beanFactoryAware;  //不能根据类型注入，因为会有多个实现类
    private BeanClassLoaderAware beanClassLoaderAware; //不能根据类型注入，因为会有多个实现类
    private EnvironmentAware environmentAware;
    private EmbeddedValueResolverAware embeddedValueResolverAware;
    private ResourceLoaderAware resourceLoaderAware;
    private ApplicationEventPublisherAware applicationEventPublisherAware;
    private MessageSourceAware messageSourceAware;
    private ApplicationContextAware applicationContextAware;
   //忽略 get/set... 方法
    
}

结论

如果按照上面的例子会报错，为啥？因为在根据类型 装配的时候 beanFactoryAware 和 beanClassLoaderAware 会有多个实现类，导致注入失败…

如果注掉 beanFactoryAware 和 beanClassLoaderAware 则会执行成功

会有一些类并没有注入成功，我们来一一演示一下

• BeanNameAware、EmbeddedValueResolverAware、ApplicationEventPublisherAware、MessageSourceAware：没有实现类~~~，也就是说需要手动去实现，当实现，当实现这个接口后，根据类型就能找到了，也就是说这些类的实现类是可以在 spring 容器中拿到

public class IgnoreDependencyInterfaceBeanB  implements  
    BeanNameAware ,
	EmbeddedValueResolverAware,
	ApplicationEventPublisherAware,
	MessageSourceAware{
    // ...
}

问题

为啥… 说好的忽略呢？为啥没有忽略到呢…难道是根据 By_NAME 忽略的吗…，那我们继续去看 By_NAME

自动装配-BY_NAME

@ComponentScan
public class IgnoreDependencyInterfaceContext {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IgnoreDependencyInterfaceContext.class);
        IgnoreDependencyInterfaceBeanB bean = context.getBean(IgnoreDependencyInterfaceBeanB.class);
        System.out.println(bean.getBeanNameAware()); // 没有自动注入
        System.out.println(bean.getEnvironmentAware());// 没有自动注入
        System.out.println(bean.getEmbeddedValueResolverAware()); // 没有自动注入
        System.out.println(bean.getResourceLoaderAware());// 没有自动注入
        System.out.println(bean.getApplicationEventPublisherAware()); // 没有自动注入
        System.out.println(bean.getMessageSourceAware()); // 没有自动注入
    }
}

• 配置类

@Configuration
public class AutowiredConfig {

	// 默认是不进行装配的，我们开启装配根据类型来，
	// 这样spring就会自动去根据 set 方法区帮我们注入Bean 
    @Bean(autowire= Autowire.BY_NAME)
    public AutowiredBeanDemoA autowiredBeanDemoA() {
        return new AutowiredBeanDemoA();
    }
}

• Bean

@Component
public class AutowiredBeanDemoA {
    // ignoreDependencyInterface 添加的接口
    private BeanNameAware beanNameAware;
    private BeanFactoryAware beanFactoryAware;  
    private BeanClassLoaderAware beanClassLoaderAware;
    private EnvironmentAware environmentAware;
    private EmbeddedValueResolverAware embeddedValueResolverAware;
    private ResourceLoaderAware resourceLoaderAware;
    private ApplicationEventPublisherAware applicationEventPublisherAware;
    private MessageSourceAware messageSourceAware;
    private ApplicationContextAware applicationContextAware;
   //忽略 get/set... 方法
}

• 打印结果

null
null
null
null
null
null
null

问题

咦，好像是忽略了，难道真的根据 name 是进行忽略的嘛，实际是不是的，而是因为，因为我们知道的 spring 注入那肯定是在容器里面去取，那我们可以做一个实验去取一下看看

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IgnoreDependencyInterfaceContext.class);
        IgnoreDependencyInterfaceBeanB bean = context.getBean(IgnoreDependencyInterfaceBeanB.class);
        System.out.println(bean.getBeanNameAware()); 
        System.out.println(bean.getEnvironmentAware());
        System.out.println(bean.getEmbeddedValueResolverAware()); 
        System.out.println(bean.getResourceLoaderAware());
        System.out.println(bean.getApplicationEventPublisherAware()); 
        System.out.println(bean.getMessageSourceAware()); 
        System.out.println(bean.getApplicationContextAware());
        //这里会报错，因为 根本就没有这个Bean那我们换一种方式去取
        Object applicationContextAware = context.getBean("applicationContextAware"); 
        // 这里并不会出现错误，因为容器里面有这个类型的Bean
        ApplicationContextAware context = context.getBean(ApplicationContextAware.class); 
        // 这里并不会出现错误，因为容器里面有这个类型的Bean
        Object bean1 = context.getBean("org.springframework.context.annotation.internalConfigurationAnnotationProcessor");



    }

得出的结论是好像跟自动忽略装配关系并不是很大…

@Autowired

• 具有强制性，也就是说，如果标注了这个注解，就必须就得存在这个 Bena ，如果没有就报错，
• 如果 非强制注入，则会跟上面结果上是一致的

@Component
public class AutowiredBeanDemoA {
	
    @Autowired(required = false)
    private BeanNameAware beanNameAware;
    
    private BeanFactoryAware beanFactoryAware;  //不能根据类型注入，因为会有多个实现类
    private BeanClassLoaderAware beanClassLoaderAware; //不能根据类型注入，因为会有多个实现类
    
    @Autowired(required = false)
    private EnvironmentAware environmentAware;
    
    @Autowired(required = false)
    private EmbeddedValueResolverAware embeddedValueResolverAware;
    
    @Autowired(required = false)
    private ResourceLoaderAware resourceLoaderAware;
    
    @Autowired(required = false)
    private ApplicationEventPublisherAware applicationEventPublisherAware;
    
    @Autowired(required = false)
    private MessageSourceAware messageSourceAware;
    
    @Autowired(required = false)
    private ApplicationContextAware applicationContextAware;

   //忽略 get/set... 方法
}

问题

为啥… 说好的忽略呢？为啥没有忽略到呢…到底是忽略啥啥啥啥…

问题

说好的忽略装配呢，到底忽略装配啥，也没见忽略呀，难道忽略了一个寂寞嘛…

通过下面的例子彻底感受一下

@ComponentScan
public class IgnoreDependencyInterfaceContext {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IgnoreDependencyInterfaceContext.class);
        IgnoreDependencyInterfaceBeanE bean = context.getBean(IgnoreDependencyInterfaceBeanE.class);
        System.out.println(bean.getApplicationContext());
    }
}

• 定义配置类

@Configuration
public class IgnoreDependencyInterfaceBeanA {
    @Bean(autowire = Autowire.BY_TYPE)
    public IgnoreDependencyInterfaceBeanE getB() {
        return new IgnoreDependencyInterfaceBeanE();
    }

}

• 定义自动装配，不实现接口

public class IgnoreDependencyInterfaceBeanE   {

    private ApplicationContext ApplicationContext;

    public org.springframework.context.ApplicationContext getApplicationContext() {
        return ApplicationContext;
    }

 
    public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext) {
        ApplicationContext = applicationContext;
    }
}

• 定义自动装配，实现接口

public class IgnoreDependencyInterfaceBeanE  implements ApplicationContextAware {

    private ApplicationContext ApplicationContext;

    public org.springframework.context.ApplicationContext getApplicationContext() {
        return ApplicationContext;
    }

    @Override
    public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext) {
        ApplicationContext = applicationContext;
    }
}

结论

可以看到 setApplicationContext 方法只是执行了一遍，按照以往的之前的尿性来看，应该会执行两次才对，一次是， 在自动装配的时候执行一次，一次是 postProcess 执行才对呀，然后结果却是，自动装配并没有执行，执行的是postProcess的回调方法

代码演示

定义启动类

@ComponentScan
public class BeanContext {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanContext.class);
        BeanA a = context.getBean(BeanA.class);
        System.out.println(a.getBeanBDemo()); //这里是 null
        System.out.println(a.getBeanCDemo());
        
    }
}

定义 A 类

• 定义接口，用于忽略 这个接口的 set 注入，简单来说就是忽略 BeanB的注入

public interface BeanAInterface {

    public void setBeanBDemo(BeanB beanBDemo);
}
 

• 定义实现类

public class BeanA implements BeanAInterface {

    private BeanB beanB;
    private BeanC beanC;
    // 省略get set 方法
}

定义 B类

@Component
public class BeanB {
}

定义 C类

@Component
public class BeanC{
}

定义配置类

@Configuration
public class BeanConfig {
 
    //开启自动装配
    @Bean(autowire = Autowire.BY_TYPE)
    public BeanA beanADemo() {
        return new BeanA();
    }
}

定义PostProcessor

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
 
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.ignoreDependencyInterface(BeanAInterface.class);
    }
}

结论

可以看到，BeanB 并没有被注入到BeanA 中，诸位可以将 我们 定义的 ignoreDependencyInterface 这个方法注掉，就会发现 BeanB 就会注入到 BeanA 中

后言

那其实也说明了一个情况，那就是如果实现了 Aware 这些接口的话，spring会通过方法回调的方式，进行一个注入，而不是采用 自动装配的方式，为什么要这么做？其实我也没特别能清楚为什么这么做，或者这么做的好处是什么？