为tiny-spring添加注解注入功能

2018-04-26

之前tiny-spring已经实现了通过xml配置类的方式自动装配和依赖注入，现在要给tiny-spring框架加入自动扫描包下的类，再执行自动装配和依赖注入。

流程步骤可以分为：

类加载器获取包路径；
扫描并加载路径下的类集合；
将扫描到的类集合解析成BeanDefinition对象集合；
交给自动装配和依赖注入；

步骤1~2可以归结为获取指定包下面的类集合，然后再解析，最后自动装配和注入。

1. 获取指定包下面的类集合

首先我们需要一个类加载器

   /**
 * 获取类加载器
 */
public static ClassLoader getDefaultClassLoader() {
	ClassLoader cl = null;
	try {
		cl = Thread.currentThread().getContextClassLoader();
	} catch (Throwable ex) {
		// Cannot access thread context ClassLoader - falling back...
	}

	if (cl == null) {
		// 如果没有当前线程的ClassLoader 则 使用当前类的ClassLoader
		cl = ClassUtils.class.getClassLoader();
		if (cl == null) {
			try {
				// 如果还是null，则获取启动程序的ClassLoader
				cl = ClassLoader.getSystemClassLoader();
			} catch (Throwable ex) {
				// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
			}
		}
	}
	return cl;
}

然后需要有通过类名，获取类对象的方法

   /**
 * 获取类
 *
 * @param className 类名
 * @param initialize 是否初始化，一般选false，交给IOC容器去初始化
 * @param loader 类加载器
 * @return 类
 * @throws ClassNotFoundException
 */
public static Class<?> loadClass(String className, boolean initialize, ClassLoader loader)
		throws ClassNotFoundException {
	return Class.forName(className, initialize, loader);
}

将上面的结合起来，获取路径下面的Class集合

  /**
 * 获取指定包下面的类
 * 根据包名并将其转换成文件路径，读取class文件或jar包，获取指定的类名去加载类。
 */
public static Set<Class<?>> getClassSet(String location) {
	Set<Class<?>> classSet = new HashSet<Class<?>>();

	try {
		Enumeration<URL> urls = getDefaultClassLoader().getResources(location.replace(".", "/"));
		while (urls.hasMoreElements()) {
			URL url = urls.nextElement();
			if (url != null) {
				String protocol = url.getProtocol();
				if (protocol.equals("file")) {
					String packagePath = url.getPath().replaceAll("%20", "");
					addClass(classSet, packagePath, location);
				} else if (protocol.equals("jar")) {
					// 获取Jar包中的类
					JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
					if (jarURLConnection != null) {
						JarFile jarFile = jarURLConnection.getJarFile();
						if (jarFile != null) {
							Enumeration<JarEntry> jarEntrys = jarFile.entries();
							while (jarEntrys.hasMoreElements()) {
								JarEntry jarEntry = jarEntrys.nextElement();
								String jarEntryName = jarEntry.getName();
								if (jarEntryName.endsWith(".class")) {
									String className = jarEntryName.substring(0, jarEntryName.lastIndexOf("."))
											.replaceAll("/", ".");
									doAddClass(classSet, className);
								}
							}
						}

					}
				}
			}
		}


	} catch (IOException e) {
		throw new RuntimeException(e);
	}
	return classSet;
}

private static void addClass(Set<Class<?>> classSet, String packagePath, String packageName) {
	final File[] files = new File(packagePath).listFiles(new FileFilter() {
		@Override
		public boolean accept(File pathname) {
			return (pathname.isFile() && pathname.getName().endsWith(".class")) || pathname.isDirectory();
		}
	});

	for (File file : files) {
		String fileName = file.getName();
		if (file.isFile()) {
			String className = fileName.substring(0, fileName.lastIndexOf("."));
			if (className != null) {
				className = packageName + "." + className;
			}
			doAddClass(classSet, className);
		} else {
			String subPackagePath = fileName;
			if (packagePath != null) {
				subPackagePath = packagePath + "/" + subPackagePath;
			}
			String subPackageName = fileName;
			if (packageName != null) {
				subPackageName = packageName + "." + subPackageName;
			}
			addClass(classSet, subPackagePath, subPackageName);
		}
	}
}

private static void doAddClass(Set<Class<?>> classSet, String className) {
	Class<?> cls = null;
	try {
		cls = loadClass(className, false);
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
	classSet.add(cls);
}

2.解析和自动装配

通过继承AbstractApplicationContext类，实现抽象方法 loadBeanDefinitions 来加载类定义，并注入到内置的BeanFactory中，然后用 refrsh方法来自动装配和依赖注入。

/**
 * 从包路径扫描和加载的具体实现类。
 * 内部通过扫描对应的包来获取类信息并解析成BeanDefinition。
 * 然后将其保存到内置的 BeanFactory 中。
 * 
 * @author muzhi
 * 18/4/27
 */
public class ClassPathScanApplicationContext extends AbstractApplicationContext {

	// 先显示的传入包路径
	private String configLocation;

	public ClassPathScanApplicationContext(String configLocation) throws Exception {
		this(configLocation, new AutowireCapableBeanFactory());
	}

	public ClassPathScanApplicationContext(String configLocation, AbstractBeanFactory beanFactory) throws Exception {
		super(beanFactory);
		this.configLocation = configLocation;
		refresh();
	}


	@Override
	protected void loadBeanDefinitions(AbstractBeanFactory beanFactory) throws Exception {
		// todo 后续继续封装成Scanner
		Set<Class<?>> classes = ClassUtils.getClassSet(this.configLocation);
		Map<String, BeanDefinition> tempFactory = new HashMap<String, BeanDefinition>();
		for (Class cl : classes) {
			BeanDefinition beanDefinition = new BeanDefinition();
			String className = cl.getName();

			beanDefinition.setBeanClassName(className);
			beanDefinition.setBeanClass(cl);

			// 注入属性
			Field[] beanFields = cl.getDeclaredFields();
			for (Field beanField : beanFields) {
				if (beanField.isAnnotationPresent(Resource.class)) {
					String fieldName = beanField.getName();
					BeanReference beanReference = new BeanReference(fieldName);
					beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(fieldName, beanReference));
				}
			}
			tempFactory.put(className, beanDefinition);
		}

		for (Map.Entry<String, BeanDefinition> beanDefinitionEntry : tempFactory.entrySet()) {
			beanFactory.registerBeanDefinition(beanDefinitionEntry.getKey(), beanDefinitionEntry.getValue());
		}

	}
}

总结

这样基本实现了，类通过扫描包自动装配，代码已经上传到 https://github.com/lingo0/tiny-spring-ling.git 。

但是和Spring框架的结构还是不一样的，之后学习Spring的框架思想再继续优化。