Spring
1. 配置文件
src/main/resources 下创建XX.properties 文件，文件里加入数据库配置信息，base_package,jsp_path,asset_path(静态资源文件的基础路径)等信息。
2. 加载配置
加载配置文件中的配置信息，将jsp_path,asset_path配置项提供默认值，以配置文件中配置的信息优先。
3. 类加载器
来加载基础包名下的所有类，比如使用了某注解的类，或实现了某个接口的类，或继承了某父类的所有子类等。获取类加载器，加载类，获取指定包下的所有类。
获取类加载器只需获取当前线程中的classLoader即可,加载类需要提供类名和是否初始化的标记，这里的初始化是指执行类的静态代码块。获取指定包名下的所有类，需要将包名转换为文件路径，读取class文件或jar包，获取指定的类名去加载类，将类放到Set中。
public static ClassLoadder getClassLoader(){ return Thread.currentThread().getContextClassLoader(); }
public static Class<?> loadClass(String className, boolean isInitialized) { Class<?> cls; try { cls = Class.forName(className, isInitialized, getClassLoader()); // 使用给定的类加载器加载类并返回Class对象 } catch (ClassNotFoundException e) { throw new RuntimeException(e); } return cls; }
public static Set<Class<?>> getClassSet(String packageName) { // 存放Class类的Set集合 Set<Class<?>> classSet = new HashSet<Class<?>>(); try { // getResource(String name) 查找具有给定名称的资源 // Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素 Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".", "/")); while (urls.hasMoreElements()) { // 判断此枚举是否包含更多的元素 URL url = urls.nextElement(); // 返回此枚举的下一个元素 if (url != null) { String protocol = url.getProtocol(); // 获取此 URL的协议名称 if(protocol.equals("file")) { String packagePath = url.getPath().replaceAll("%20", ""); // getPath() 获取此 URL 的路径部分 addClass(classSet, packagePath, packageName); } else if (protocol.equals("jar")) { JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection(); if (jarURLConnection != null) { JarFile jarFile = jarURLConnection.getJarFile(); if (jarFile != null) { Enumeration<JarEntry> jarEntries = jarFile.entries(); while (jarEntries.hasMoreElements()) { JarEntry jarEntry = jarEntries.nextElement(); String jarEntryName = jarEntry.getName(); if (jarEntryName.endsWith(".class")) { String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/", "."); doAddClass(classSet, className); } } } } } } } } catch (Exception e) { e.printStackTrace(); } return classSet; }
/** * 递归遍历类或文件，判断是否是.class文件或者标准文件 * @param classSet * @param packagePath * @param packageName */ public static void addClass(Set<Class<?>> classSet, String packagePath, String packageName) { File[] files = new File(packagePath).listFiles(new FileFilter() { public boolean accept(File file) { return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory(); } }); for (File file : files) { String fileName = file.getName(); if (file.isFile()) { // 此抽象路径名表示的文件是否是一个标准文件 String className = fileName.substring(0, fileName.lastIndexOf(".")); if (StringUtil.isNotEmpty(packageName)) { className = packageName + "." + className; } else { String subPackagePath = fileName; if (StringUtil.isNotEmpty(packagePath)) { subPackagePath = packagePath + "/" + subPackagePath; } String subPackageName = fileName; if (StringUtil.isNotEmpty(packageName)) { subPackageName = packageName + "." +subPackageName; } addClass(classSet, subPackagePath, subPackageName); } } } } /** * 将类放入 Set<Class<?>> 中 * @param classSet 存放Class类的Set集合 * @param className 类名 */ public static void doAddClass(Set<Class<?>> classSet, String className) { Class<?> cls = loadClass(className, false); classSet.add(cls); }
ClassHelper.class用于获取应用包名下所有Service类，Controller类，将带有@Controller，@Service注解的类所产生的对象，理解为由框架所管理的bean，获取应用包名下所有bean的方法，同样将bean放到Set中，先由上述代码获取所有类，然后从类中查找包含固定注解的类加入到Set中：
/** * 定义Class类的Set集合（用于存放所加载的类） */ private static final Set<Class<?>> CLASS_SET; static { String basePackage = ConfigHelper.getAppBasePackage(); CLASS_SET = ClassUtil.getClassSet(basePackage); } /** * 获取应用包名下的所有的类 * @return Set集合泛型为Class类 */ public static Set<Class<?>> getClassSet() { return CLASS_SET; } /** * 获取应用包名下的所有Service类 * @return Set集合泛型为Class类 */ public static Set<Class<?>> getServiceClassSet() { Set<Class<?>> classSet = new HashSet<Class<?>>(); for (Class<?> cls : CLASS_SET) { if (cls.isAnnotationPresent(Service.class)) { classSet.add(cls); } } return classSet; } /** * 获取应用包名下的所有Controller类 * @return Set集合泛型为Class类 */ public static Set<Class<?>> getControllerClassSet() { Set<Class<?>> classSet = new HashSet<Class<?>>(); for (Class<?> cls : CLASS_SET) { if (cls.isAnnotationPresent(Controller.class)) { classSet.add(cls); } } return classSet; } /** * 获取应用包名下所有Bean类（包括：Service、Controller等） * @return Set集合泛型为Class类 */ public static Set<Class<?>> getBeanClassSet() { Set<Class<?>> beanClassSet = new HashSet<Class<?>>(); beanClassSet.addAll(getServiceClassSet()); beanClassSet.addAll(getControllerClassSet()); return beanClassSet; }
4. bean容器
前边获取了所加载的类，但是无法通过类来实例化对象，因此要通过反射来对所加载的类进行实例化，bean类与bean实例的映射关系放到Map中。
public final class ReflectionUtil { /** * 创建类的实例 * @param cls Class类的实例 * @return Object 类型的对象 */ public static Object newInstance(Class<?> cls) { Object instance = null; try { instance = cls.newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } return instance; } /** * 调用方法 * @param obj Object类的对象 * @param method Method类的对象 * @param args 可变的Object类型的参数 * @return */ public static Object invokeMethod(Object obj, Method method, Object... args) { Object result = null; method.setAccessible(true); // 如果获取到的method是private，不设置为true，就会报错 try { method.invoke(obj, args); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return result; } /** * 设置成员变量的值 * @param obj Object类的对象 * @param field Field类的对象 * @param value Object类的对象 */ public static void setField(Object obj, Field field, Object value) { field.setAccessible(true); // 如果获取到的field是private，不设置为true，就会报错 try { field.set(obj, value); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } }
/** * 定义Bean映射（用于存放Bean类与Bean实例的映射关系） */ private static final Map<Class<?>, Object> BEAN_MAP = new HashMap<Class<?>, Object>(); static { Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet(); for (Class<?> beanClass : beanClassSet) { Object obj = ReflectionUtil.newInstance(beanClass); BEAN_MAP.put(beanClass, obj); } } /** * 获取Bean映射 * @return Map<Class<?>, Object> 对象 */ public static Map<Class<?>, Object> getBeanMap() { return BEAN_MAP; } /** * 获取Bean实例 * @param cls Class类 * @return */ @SuppressWarnings("unchecked") public static <T> T getBean(Class<T> cls) { // <T>表明T是一个泛型，没有明确的类型 if (!BEAN_MAP.containsKey(cls)) { throw new RuntimeException("can not get bean by class:" + cls); } return (T) BEAN_MAP.get(cls); }
在bean map中存放了bean类与bean实例的映射关系，只需要调用getBean方法，传入一个bean类就能获取bean实例，这就是bean容器了。
5. 依赖注入
在Controller中定义了Service变量，如何在Controller的方法中调用Service成员变量的方法呢？如何实例化Service成员变量呢？通过框架自身来实例化，这种实例化过程就是IOC啦，先通过Bean Map（类和对象的映射关系），遍历这个映射关系，取出bean和bean实例，然后通过反射获取类中所有的成员变量，在循环中遍历当前成员变量，判断是否带有自定义注解，若带有自定义注解，则从bean map中取出bean实例，最后通过反射修改当前成员变量的值。
public final class IocHelper { static { // 获取所有的 Bean 类与 Bean 实例之间的映射关系（简称 Bean Map） Map<Class<?>, Object> beanMap = BeanHelper.getBeanMap(); if (CollectionUtil.isNotEmpty(beanMap)) { // 遍历 Bean Map for (Map.Entry<Class<?>, Object> beanEntry : beanMap.entrySet()) { // 从 BeanMap 中获取 Bean 类与 Bean 实例 Class<?> beanClass = beanEntry.getKey(); Object beanInstance = beanEntry.getValue(); // 获取 Bean 类定义的所有成员变量（简称 Bean Field） Field[] beanFields = beanClass.getDeclaredFields(); if (ArrayUtil.isNotEmpty(beanFields)) { for (Field beanField : beanFields) { // 判断当前 Bean Field 是否带有 Inject 注解 if (beanField.isAnnotationPresent(Inject.class)) { // 在 Bean Map 中获取 Bean Field 对应的实例 Class<?> beanFieldClass = beanField.getType(); Object beanFieldInstance = beanMap.get(beanFieldClass); if (beanFieldInstance != null) { // 通过反射初始化 BeanField 的值 ReflectionUtil.setField(beanInstance, beanField, beanFieldInstance); } } } } } } } }
在静态块中实现相关逻辑，完成IOC容器的初始化工作，当这个类被加载的时候，就应该加载它的静态块，IOC框架所管理的bean都是单例的，由于bean map 中的对象都是事先创建好并放入这个bean容器的，所以所有的bean都是单例的。
5. 加载Controller
