Spring解读@Component和@Configuration的区别以及源码分析

2024-10-29 11:38 开发作者：魔道不误砍柴功

1、案例演示

定义一个 Apple 实体类，通过 @Bean 的方式交给 Spring 管理，如下：

public class Apple {

}

在定义一个 AppleFactory 工厂类也可以获取到 Apple 类实例，如下：

public class AppleFactory {

	private Apple apple;

	public Apple getApple() {
		return apple;
	}

	public void setApple(Apple apple) {
		this.apple = apple;
	}
}

在定义一个 AppleAutoConfiguration 类，此时先用 @Configuration 注解修饰该类，如下：

@Configuration
public class AppleAutoConfiguration {

	@Bean
	public Apple apple() {
		return new Apple();
	}

	@Bean
	public AppleFactory appleFactory() {
		AppleFactory appleFactory = new AppleFactory();

		appleFactory.setApple(apple());
		return appleFactory;
	}
}

先来分析下 AppleAutoConfiguration 类中的方法，apple() 方法中直接通过 new 关键字创建了一个 Apple 对象，这个没啥问题

继续看到 appleFactory() 方法内部，又调用了 apple() 方法，此时仔细想想，Spring 是不是调用了两次 apple() ，第一次是 Spring 扫描到 @Bean 注解调用一次，第二次是在 Spring 扫描到 @Bean 注解调用 appleFactory() 方法，appleFactory() 方法中又调用一次 apple() 方法，调两次 new 创建对象，必然会出现两个不一样的 Apple 对象，这样必然违背了 Spring 单例设计思想。

接下来测试下结果，看下是不是和我们想象的结果一样呢？

测试如下：

@ComponentScan
public class ComponentConfigurationTest {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ComponentConfigurationTest.class);


		AppleFactory appleFactory = context.getBean(AppleFactory.class);
		Apple apple = appleFactory.getApple();
		System.out.println("从 AppleFactory 获取的 apple = " + apple);


		Apple bean = context.getBean(Apple.class);
		System.out.println("从 Spring 容器中获取的 apple = " + bean);
	}
}

最终输出结果如下：

从 AppleFactory 获取的 apple = com.gwm.configurationanno.Apple@2f465398
从 Spring 容器中获取的 apple = com.gwm.configurationanno.Apple@2f465398

发现这结果和我们刚刚的猜想不一样啊，其实大家隐约应该猜到，是因为这里使用的是 @Configuration 注解，所以这里最终你调用多少次最终都是同一个对象，原理稍后分析。

那么接下来肯定是要把 @Configuration 注解替换成 @Component 试试，修改之后的代码如下：

@Component
public class AppleAutoConfiguration {

	@Bean
	public Apple apple() {
		return new Apple();
	}

	@Bean
	public AppleFactory appleFactory() {
		AppleFactory appleFactory = new AppleFactory();

		appleFactory.setApple(apple());
		return appleFactory;
	}
}

测试结果如下：

从 AppleFactory 获取的 apple = com.gwm.configurationanno.Apple@2f465398
从 Spring 容器中获取的 apple = com.gwm.configurationanno.Apple@2f465353

最终发现这个结果和我们在前面想象的结果一模一样，果然就创建了两个 Apple 对象，违背了 Spring 单例设计思想，这个区别非常非常的重要，因为在 SpringBoot 中为什么配置类都是使用的 @Configuration 注解，并不是直接使用 @Component 注解，这个原因想必大家应该也知道了。

上面这个例子在 SpringBoot 中有非常多的应用，在来看下另一个例子，如下：

定义一个 Orange 实体类，通过 FactoryBean 接口将 Orange 类交给 Spring 管理，如下：

public class Orange {

}

再定义个 OrangeFactoryBean 类实现 FactoryBean 接口，调用 getObject() 方法可以创建 Orange 对象，如下：

public class OrangeFactoryBean implements FactoryBean<Orange> {
	@Override
	public Orange getObject() throws Exception {
		return new Orange();
	}

	@Override
	public Class<?> getObjectType() {
		return Orange.class;
	}
}

大家都知道实现了 FactoryBean 接口的类最终会去调用 getObject() 方法然后创建对象。然后再在 AppleAutoConfiguration 类中调用 getObject() 方法，这里直接使用 @Component 注解演示，因为 @Configuration 注解肯定是没问题的，如下：

@Component
public class AppleAutoConfiguration {

	@Bean
	public Apple apple() {
		return new Apple();
	}

	@Bean
	public AppleFactory appleFactory() throws Exception {
		AppleFactory appleFactory = new AppleFactory();

		appleFactory.setApple(apple());
		
		OrangeFactoryBean orangeFactoryBean = orangeFactoryBean();
		System.out.println("appleFactory orangeFactoryBean = " + orangeFactoryBean);
		Orange orange = orangeFactoryBean.getObject();
		System.out.println("appleFactory orange="+orange);
		return appleFactory;
	}

	@Bean
	public OrangeFactoryBean orangeFactoryBean() {
		return new OrangeFactoryBean();
	}
}

这里通过 @Bean 注入 OrangeFactoryBean 实例，因为 AppleAutoConfiguration 类被 @Component 修饰，所以这里 Spring 和手动调用两次创建的 OrangeFactoryBean 不一样，导致 getObject() 其实也是不一样的。

测试代码如下：

@ComponentScan
public class ComponentConfigurationTest {
	public static void main(String[] args) throws Exception {
		AnnotationConfigApplicationContext context = new Annothttp://www.devze.comationConfigApplicationContext(ComponentConfigurationTest.class);


		AppleFactory appleFactory = context.getBean(AppleFactory.class);
		Apple apple = appleFactory.getApple();
		System.out.println("从 AppleFactory 获取的 apple = " + apple);


		Apple bean = context.getBean(Apple.class);
		System.out.println("从 Spring 容器中获取的 apple = " + bean);


		Orange bean1 = context.getBean(Orange.class);
		System.out.println("从 Spring 容器中获取的 orange = "+bean1);

		Object bean2 = context.getBean("orangeFactoryBean");
		System.out.println("=>从 Spring 容器中获取的 orange = " + bean2);

		OrangeFactoryBean bean3 = context.getBean(OrangeFactoryBean.class);
		System.out.println("bean3 = " + bean3);
	}
}

输出结果如下：

appleFactory orangeFactoryBean = com.gwm.configurationanno.OrangeFactoryBean@c0c2f8d
appleFactory orange=com.gwm.configurationanno.Orange@305b7c14
从 AppleFactory 获取的 apple = com.gwm.configurationanno.Apple@484970b0
从 Spring 容器中获取的 apple = com.gwm.configurationanno.Apple@4470f8a6
从 Spring 容器中获取的 orange = com.gwm.configurationanno.Orange@7c83dc97
=>从 Spring 容器中获取的 orange = com.gwm.configurationanno.Orange@7c83dc97
Spring 容器中的 orangeFactoryBean = com.gwm.configurationanno.OrangeFactoryBean@7748410a

通过以上两个案例可以清楚的知道 @Configuration 和 @Component 注解的区别，那么这个底层是怎么实现的呢？

2、源码解析

2.1、@Configuration 简单思路分析

这里我们可以大致的思考下，产生多个实例无非就是没有从 Spring 缓存中取值嘛，如果都是从 Spring 缓存中取值，那么必然就不会出现那么多对象。

对于 apple() 方法因为被 @Bean 修饰，所以在 Spring 实例化过程中会被调用，然后创建完实例将其放到 Spring 单例缓冲池中，那么下次就可以直接从缓存中获取到 Apple 实例（@Bean 注入 bean 流程看另一篇文章）。

对于 appleFactory() 方法中去调用 apple() 方法，apple() 方法又会 new 一个新的 Apple 实例，那么怎么样避免它重复创建对象呢？是不是可以通过代理改变 apple() 方法内部的逻辑，改成让它直接从 Spring 缓冲池中获取 Apple 的实例，这样就避免了重复创建对象。

如果要把 apple() 方法改成代理方法，是不是需要将所在的类 AppleAutoConfiguration 变成代理对象即可，Spring 就是这样干的，加上 @Configuration 注解标识之后，Spring 就会通过 cglib 代理创建 AppleAutoConfiguration 实例，所以你在 Spring 容器中获取 AppleAutoConfiguration 类是一个代理类，并不是真正的实体类。

跟着上述思路再去看源码，就简单多了。