spring源码之模拟扫描器

之前写Junit测试类的时候，我们都会给spring容器手动注入一个配置类，里面会用@ComponentScan来告诉spring需要扫描的路径。如下图：

那么spring就是通过这个配置类的注解，拿到我们定义的路径，然后从电脑中的绝对路径读取到.class文件进行解析。
大概流程如下：

1. ConfigrarionClassPostProcessor
2. 获取包名
3. 得到路径下的所有文件
4. 通过ASM的方式读取字节码信息，生成类
5. 验证是否符合规则，生成beanDefinition
6. 放入map中

我们可以通过代码模拟一下这个流程

public class MyScaner {

	File f = new File(this.getClass().getResource("/").getPath());
	public List<String> listName = new ArrayList<>();
	public Map<String, AbstractBeanDefinition> map = new HashMap<>();


	//这个方法一旦完成，就是完成了spring的扫描
	//listName中存了左右符合规则的bean名字
	//map中存了所有beanName以及对应的beanDefinition
	public void scan(String packageName) throws ClassNotFoundException {

		System.out.println("packageName = " + packageName);
		String scanPath = "";
		//获取当前类的存放绝对路径
		//  /Users/xxxx/Downloads/idea/spring-framework-5.2.x/spring-example/src/main/java/com/spring/scan
		//  /Users/shang/Downloads/idea/spring-framework-5.2.x/spring-example/out/test/classes/com/spring/scan/bean/A.class
		//  /Users/shang/Downloads/idea/spring-framework-5.2.x/spring-example/out/test/classes/com/spring/scan/bean
		String rootPath = f.getPath();
		System.out.println("rootPath = " + rootPath);

		//传入的包路径将. 替换为\
		//com.spring.scan --- com\spring\scan
		scanPath = packageName.replaceAll("\\.", "/");
		System.out.println("scanPath = " + scanPath);

		//拼接绝对路径
		rootPath = rootPath+ "/"+ scanPath;
		System.out.println("rootPath = " + rootPath);

		//取出文件夹下的文件，这里只是简单取出了，没有处理文件夹中的文件夹
		File rootDir = new File(rootPath);
		String[] list = rootDir.list();
		if (list == null || list.length == 0) {
			System.out.println("bean null");
			return;
		}
		for (String s : list) {
			s = s.replaceAll(".class", "");
			System.out.println("s = " + s);

			String beanName = s.toLowerCase();
			System.out.println("beanName = " + beanName);

			s = packageName + "." + s;
			System.out.println("s = " + s);


			//通过反射的方式获取bean
			//spring中是通过ASM字节码的方式获取，优点是不会提前执行构造方法
			Class<?> clazz = Class.forName(s);

			//如果有Component注解的话才处理
			if (clazz.isAnnotationPresent(Component.class)) {
				GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
				beanDefinition.setBeanClass(clazz);
				
				//如果自定义了bean的作用域的话就放入这个组件中
				if(clazz.isAnnotationPresent(Scope.class)){
					beanDefinition.setScope(clazz.getAnnotation(Scope.class).value());
				}

				map.put(beanName, beanDefinition);
				listName.add(beanName);
			}
		}

	}

}



public class ScanBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {


	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		try{
			MyScaner myScaner = new MyScaner();
			myScaner.scan("com.spring.scan.bean");
			//

			List<String> listName = myScaner.listName;
			Map<String, AbstractBeanDefinition> map = myScaner.map;
			for (String s : listName) {
				registry.registerBeanDefinition(s, map.get(s));

			}
		}catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

	}
}

//注意这三个类，因为是用Junit Test运行的，所以这三个类也要跟测试类在一块
@Component
public class A {

	@PostConstruct
	public void init() {
		System.out.println("A init");
	}
}

public class B {

	@PostConstruct
	public void init() {
		System.out.println("B init");
	}
}

@Component
public class C {

	@PostConstruct
	public void init() {
		System.out.println("C init");
	}
}

public class ScanTest {

	@Test
	public void defaultScanTest() {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		context.addBeanFactoryPostProcessor(new ScanBeanDefinitionRegistryPostProcessor());
		context.refresh();
	}
}

这个测试的方法与spring不一样的是第4步。

测试方法是通过反射获取类对象；而spring是通过ASM方式获取获取的，这个我也不懂，是一个跟高深的学问。
只是知道他的优势在于，不会提前执行static代码块。
因为如果用反射的方式获取的话，就直接把类加载到JVM了，如果类中有static代码块并且还关联了其他类，那不就要报错了吗。而通过ASM获取的话就不会，只是获取这个文件而已。
这就是spring优秀的地方

PS：
spring的扫描注解什么情况不会生效。
在正常的扫描过程中，如果扫描到的类中，有ComponentScan注解的话，也会读取，然后按照配置继续扫描
如下：

@ComponentScan("com.spring.other")
public class A {

	@PostConstruct
	public void init() {
		System.out.println("A init");
	}
}

但是，这个类如果是通过BeanDefinitionPostProcessor类注册进来的话，ComponentScan就不会生效了，因为扫描的工作在执行BeanDefinitionPostProcessor回调方法之前就已经完成了。