代码已上传到GitHub，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-CodeAnalysis-Demo
在上一节，我们知道SpringIOC的原理是使用了XML技术+发射技术，本文主要讲解如何手写SpringIOC。
步骤一：添加用到的maven依赖
<!-- 1.Spring核心依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.3.7.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.3.7.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.7.RELEASE</version> </dependency> <!-- 2.Spring dao依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.3.7.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>4.3.7.RELEASE</version> </dependency> <!-- AOP --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.9.1</version> </dependency> <!-- 数据库 --> <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.25</version> </dependency> <!-- https://mvnrepository.com/artifact/dom4j/dom4j --> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <!-- https://mvnrepository.com/artifact/commons-lang/commons-lang --> <dependency> <groupId>commons-lang</groupId> <artifactId>commons-lang</artifactId> <version>2.6</version> </dependency> <!-- Spring单元测试 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>4.2.5.RELEASE</version> <scope>test</scope> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency>
步骤二：编写XML解析文件
先看看ClassPathXmlApplicationContext源码：
我们会发现ClassPathXmlApplicationContext 继承了 AbstractXmlApplicationContext，一路追踪下去，会发现集成关系是这样的(继承了很多层)：
ClassPathXmlApplicationContext extends -> AbstractXmlApplicationContext extends ->AbstractRefreshableConfigApplicationContext extends ->AbstractRefreshableApplicationContext extends ->AbstractApplicationContext extends ->DefaultResourceLoader
下面来简单的写一个ClassPathXmlApplicationContext：
package com.ylw.ioc; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.io.SAXReader; import org.springframework.util.StringUtils; import java.io.InputStream; import java.util.List; public class ClassPathXmlApplicationContext { // xml路径地址 private String xmlPath; public ClassPathXmlApplicationContext(String xmlPath) { this.xmlPath = xmlPath; } public Object getBean(String beanId) throws Exception { // 1. 读取配置文件 List<Element> elements = readerXml(); if (elements == null) { throw new Exception("该配置文件没有子元素"); } // 2. 使用beanId查找对应的class地址 String beanClass = findXmlByIDClass(elements, beanId); if (StringUtils.isEmpty(beanClass)) { throw new Exception("未找到对应的class地址"); } // 3. 使用反射机制初始化，对象 Class<?> forName = Class.forName(beanClass); return forName.newInstance(); } // 读取配置文件信息 public List<Element> readerXml() throws DocumentException { SAXReader saxReader = new SAXReader(); if (StringUtils.isEmpty(xmlPath)) { new Exception("xml路径为空..."); } Document read = saxReader.read(getClassXmlInputStream(xmlPath)); // 获取根节点信息 Element rootElement = read.getRootElement(); // 获取子节点 List<Element> elements = rootElement.elements(); if (elements == null || elements.isEmpty()) { return null; } return elements; } // 使用beanid查找该Class地址 public String findXmlByIDClass(List<Element> elements, String beanId) throws Exception { for (Element element : elements) { // 读取节点上是否有value String beanIdValue = element.attributeValue("id"); if (beanIdValue == null) { throw new Exception("使用该beanId为查找到元素"); } if (!beanIdValue.equals(beanId)) { continue; } // 获取Class地址属性 String classPath = element.attributeValue("class"); if (!StringUtils.isEmpty(classPath)) { return classPath; } } return null; } // 读取xml配置文件 public InputStream getClassXmlInputStream(String xmlPath) { InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(xmlPath); return resourceAsStream; } }
步骤三：编写ClassPathXmlApplicationContext 注解
1.通用的反射工具类
package com.ylw.ioc.util; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net.URLDecoder; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import java.util.jar.JarEntry; import java.util.jar.JarFile; public class ClassUtil { /** * 取得某个接口下所有实现这个接口的类 */ public static List<Class> getAllClassByInterface(Class c) { List<Class> returnClassList = null; if (c.isInterface()) { // 获取当前的包名 String packageName = c.getPackage().getName(); // 获取当前包下以及子包下所以的类 List<Class<?>> allClass = getClasses(packageName); if (allClass != null) { returnClassList = new ArrayList<Class>(); for (Class classes : allClass) { // 判断是否是同一个接口 if (c.isAssignableFrom(classes)) { // 本身不加入进去 if (!c.equals(classes)) { returnClassList.add(classes); } } } } } return returnClassList; } /* * 取得某一类所在包的所有类名 不含迭代 */ public static String[] getPackageAllClassName(String classLocation, String packageName) { // 将packageName分解 String[] packagePathSplit = packageName.split("[.]"); String realClassLocation = classLocation; int packageLength = packagePathSplit.length; for (int i = 0; i < packageLength; i++) { realClassLocation = realClassLocation + File.separator + packagePathSplit[i]; } File packeageDir = new File(realClassLocation); if (packeageDir.isDirectory()) { String[] allClassName = packeageDir.list(); return allClassName; } return null; } /** * 从包package中获取所有的Class * * @return */ public static List<Class<?>> getClasses(String packageName) { // 第一个class类的集合 List<Class<?>> classes = new ArrayList<Class<?>>(); // 是否循环迭代 boolean recursive = true; // 获取包的名字 并进行替换 String packageDirName = packageName.replace('.', '/'); // 定义一个枚举的集合 并进行循环来处理这个目录下的things Enumeration<URL> dirs; try { dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName); // 循环迭代下去 while (dirs.hasMoreElements()) { // 获取下一个元素 URL url = dirs.nextElement(); // 得到协议的名称 String protocol = url.getProtocol(); // 如果是以文件的形式保存在服务器上 if ("file".equals(protocol)) { // 获取包的物理路径 String filePath = URLDecoder.decode(url.getFile(), "UTF-8"); // 以文件的方式扫描整个包下的文件 并添加到集合中 findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes); } else if ("jar".equals(protocol)) { // 如果是jar包文件 // 定义一个JarFile JarFile jar; try { // 获取jar jar = ((JarURLConnection) url.openConnection()).getJarFile(); // 从此jar包 得到一个枚举类 Enumeration<JarEntry> entries = jar.entries(); // 同样的进行循环迭代 while (entries.hasMoreElements()) { // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件 JarEntry entry = entries.nextElement(); String name = entry.getName(); // 如果是以/开头的 if (name.charAt(0) == '/') { // 获取后面的字符串 name = name.substring(1); } // 如果前半部分和定义的包名相同 if (name.startsWith(packageDirName)) { int idx = name.lastIndexOf('/'); // 如果以"/"结尾 是一个包 if (idx != -1) { // 获取包名 把"/"替换成"." packageName = name.substring(0, idx).replace('/', '.'); } // 如果可以迭代下去 并且是一个包 if ((idx != -1) || recursive) { // 如果是一个.class文件 而且不是目录 if (name.endsWith(".class") && !entry.isDirectory()) { // 去掉后面的".class" 获取真正的类名 String className = name.substring(packageName.length() + 1, name.length() - 6); try { // 添加到classes classes.add(Class.forName(packageName + '.' + className)); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } } } catch (IOException e) { e.printStackTrace(); } } } } catch (IOException e) { e.printStackTrace(); } return classes; } /** * 以文件的形式来获取包下的所有Class * * @param packageName * @param packagePath * @param recursive * @param classes */ public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes) { // 获取此包的目录 建立一个File File dir = new File(packagePath); // 如果不存在或者 也不是目录就直接返回 if (!dir.exists() || !dir.isDirectory()) { return; } // 如果存在 就获取包下的所有文件 包括目录 File[] dirfiles = dir.listFiles(new FileFilter() { // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件) public boolean accept(File file) { return (recursive && file.isDirectory()) || (file.getName().endsWith(".class")); } }); // 循环所有文件 for (File file : dirfiles) { // 如果是目录 则继续扫描 if (file.isDirectory()) { findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes); } else { // 如果是java类文件 去掉后面的.class 只留下类名 String className = file.getName().substring(0, file.getName().length() - 6); try { // 添加到集合中去 classes.add(Class.forName(packageName + '.' + className)); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } }
2.定义ExtService注解
package com.ylw.ioc.anonnation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; // 自定义注解 service 注入bean容器 @Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface ExtService { }
3.ClassPathXmlApplicationContext
package com.ylw.ioc.anonnation; import com.ylw.ioc.util.ClassUtil; import org.apache.commons.lang.StringUtils; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ConcurrentHashMap; public class ClassPathXmlApplicationContext { // 扫包范围 private String packageName; ConcurrentHashMap<String, Object> initBean = null; public ClassPathXmlApplicationContext(String packageName) { this.packageName = packageName; } // 使用beanID查找对象 public Object getBean(String beanId) throws Exception { // 1.使用反射机制获取该包下所有的类已经存在bean的注解类 List<Class> listClassesAnnotation = findClassExisService(); if (listClassesAnnotation == null || listClassesAnnotation.isEmpty()) { throw new Exception("没有需要初始化的bean"); } // 2.使用Java反射机制初始化对象 initBean = initBean(listClassesAnnotation); if (initBean == null || initBean.isEmpty()) { throw new Exception("初始化bean为空!"); } // 3.使用beanID查找查找对应bean对象 Object object = initBean.get(beanId); // 4.使用反射读取类的属性,赋值信息 attriAssign(object); return object; } // 使用反射读取类的属性,赋值信息 public void attriAssign(Object object) throws IllegalArgumentException, IllegalAccessException { // 1.获取类的属性是否存在 获取bean注解 Class<? extends Object> classInfo = object.getClass(); Field[] declaredFields = classInfo.getDeclaredFields(); for (Field field : declaredFields) { // 属性名称 String name = field.getName(); // 2.使用属性名称查找bean容器赋值 Object bean = initBean.get(name); if (bean != null) { // 私有访问允许访问 field.setAccessible(true); // 给属性赋值 field.set(object, bean); continue; } } } // 使用反射机制获取该包下所有的类已经存在bean的注解类 public List<Class> findClassExisService() throws Exception { // 1.使用反射机制获取该包下所有的类 if (StringUtils.isEmpty(packageName)) { throw new Exception("扫包地址不能为空!"); } // 2.使用反射技术获取当前包下所有的类 List<Class<?>> classesByPackageName = ClassUtil.getClasses(packageName); // 3.存放类上有bean注入注解 List<Class> exisClassesAnnotation = new ArrayList<Class>(); // 4.判断该类上属否存在注解 for (Class classInfo : classesByPackageName) { ExtService extService = (ExtService) classInfo.getDeclaredAnnotation(ExtService.class); if (extService != null) { exisClassesAnnotation.add(classInfo); continue; } } return exisClassesAnnotation; } // 初始化bean对象 public ConcurrentHashMap<String, Object> initBean(List<Class> listClassesAnnotation) throws InstantiationException, IllegalAccessException { ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap<String, Object>(); for (Class classInfo : listClassesAnnotation) { // 初始化对象 Object newInstance = classInfo.newInstance(); // 获取父类名称 String beanId = toLowerCaseFirstOne(classInfo.getSimpleName()); concurrentHashMap.put(beanId, newInstance); } return concurrentHashMap; } // 首字母转小写 public static String toLowerCaseFirstOne(String s) { if (Character.isLowerCase(s.charAt(0))) return s; else return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString(); } }
总结
