Spring_02-IOC容器(知识记录)-CSDN博客

本文探讨了Dom4j和SAX解析XML的优缺点，并展示了如何使用Dom4j进行DOM操作，以及自定义的Spring XML和注解版IOC容器的实现，突出了内存效率和依赖管理的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、XML解析

Dom4j、Sax、Pull

Dom4j解析是将文件加载到内存中，所以如果加载大型xml文件会造成内存溢出。Sax是基于事件来对xml进行解析的，所以它可以解析大型xml文件。但Dom4j在对xml 进行增删改查和导航比较灵活。

public class Test01 {
    public static void main(String[] args) throws DocumentException {
        new Test01().test01();
    }
    public void test01() throws DocumentException {
        SAXReader saxReader=new SAXReader();
        //读取xml文件
        Document document=saxReader.read(getResourceAsStream("student.xml"));
        //读取根节点
        Element rootElement=document.getRootElement();
        //读取根节点下所有子节点
        getNodes(rootElement);
    }
    public void getNodes(Element rootElement){
        System.out.println("节点名称："+rootElement.getName());
        //获取节点的属性
        List<Attribute> attributes=rootElement.attributes();
        for(Attribute att:attributes){
            //获取属性名称和值
            System.out.println(att.getName()+"---"+att.getText());
        }
        String text=rootElement.getTextTrim();
        if(StringUtils.isNotEmpty(text)){
            System.out.println("text:"+text);
        }
        //使用迭代器获取子节点信息
        Iterator iterator=rootElement.elementIterator();
        while(iterator.hasNext()){
            Element element=(Element)iterator.next();
            getNodes(element);
        }
    }
    //获得xml 文件流
    public  InputStream getResourceAsStream(String xmlPath){
        InputStream in=this.getClass().getClassLoader().getResourceAsStream(xmlPath);
        return in;
    }

}

二、自定义IOC容器--XML版

思路：

1.自定义一个ClassPathXmlApplicationContext.java类，实现 getBean 方法。

2.读取spring.xml文件，获取到所有的根节点下的子节点。

3.遍历查找所有子节点，判断每个节点的id是否与beanId参数相同

4.获得到相同id的节点，再获取该节点的class属性

5.以反射机制初始化对象并返回

public class ClassPathXmlApplicationContext {
    private String xmlPath;

    public ClassPathXmlApplicationContext(String xmlPath){
        this.xmlPath=xmlPath;
    }

    public Object getBean(String beanId) throws Exception {
        //1 读取配置文件
        List<Element> elements=readerXml();
        //2 根据beanId 遍历所有的节点，进行查找
        String classPath=findClass(elements,beanId);
        if(StringUtils.isEmpty(classPath)){
            throw new Exception("class not find");
        }
        //3 使用反射机制 初始化对象
        Class<?> obj=Class.forName(classPath);
        return obj.newInstance();
    }

    public String findClass(List<Element> elements,String beanId) throws Exception {
        //循环所有节点，判断节点的id是否等于 beanId
        for(Element e:elements){
            String id=e.attributeValue("id");
            if(StringUtils.isEmpty(id)){
                throw new Exception(e.getName()+"未找到id属性");
            }
            if(!id.equals(beanId)) continue;
            String classPath=e.attributeValue("class");
            if(StringUtils.isNotEmpty(classPath)) return classPath;
        }
        return null;
    }


    //读取xml 返回根节点下所有子节点
    public List<Element> readerXml() throws Exception {
        SAXReader saxReader=new SAXReader();
        if(StringUtils.isEmpty(xmlPath)){
            throw new Exception("xml路径为空");
        }
        //读取xml
        Document doc=saxReader.read(getResourceAsStream(xmlPath));
        //获取根节点信息
        Element root=doc.getRootElement();
        //获取所有子节点
        List<Element> elements=root.elements();
        return elements;
    }


    //获得xml 文件流
    public InputStream getResourceAsStream(String xmlPath){
        InputStream in=this.getClass().getClassLoader().getResourceAsStream(xmlPath);
        return in;
    }

}

//测试类
public class Test02 {
    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        UserDao userDao=(UserDao)app.getBean("user");
        System.out.println("userdao:"+userDao);
    }
}

三、自定义IOC容器--注解版

思路：自定义@ExtService(@Service) 和 @ExtResource(@Resource)注解

1.根据包名获取所有类

2.循环判断类中是否含有@ExtService注解

3.定义Map集合，利用反射机制将带有@ExtService注解的类初始化并存储在Map中

4.循环Map集合，判断类属性中是否带有@ExtResource注解，从Map中获取bean给属性赋值。

//定义注解
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtService {
    String value() default "";
}

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtResource {
}


//自定义ExtClassPathXmlApplicationContext

public class ExtClassPathXmlApplicationContext {
    private String packageName;
    private ConcurrentHashMap<String,Object> beanMap=null;
    public ExtClassPathXmlApplicationContext(String packageName) throws IllegalAccessException, InstantiationException {
        this.packageName=packageName;
        //获取所有ExtService bean
        initBean();
        //给类的属性赋值
        initAttriAssign();
    }

    public Object getBean(String beanId) throws Exception {
        if(StringUtils.isEmpty(beanId)){
            throw new Exception("beanId不能这空");
        }
        Object obj=beanMap.get(beanId);
        return obj;
    }

    //初始化对象
    public void initBean() throws InstantiationException, IllegalAccessException {
        //1 扫包获取所有packageName下所有类
       List<Class<?>> list=ClassUtil.getClasses(packageName);
        //2 判断类是否有ExtService 注解
       findClassExtService(list);
    }
    public void initAttriAssign() throws IllegalAccessException {
        for(String key:beanMap.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
            Object obj = beanMap.get(key);//
            attriAssign(obj);
        }
    }
    //获取类的属性，判断是否有ExtResource注解，
    public void attriAssign(Object obj) throws IllegalAccessException {
        //1.获取对象的class
        Class<? extends Object> classinfo=obj.getClass();
        //2.获取类的所有属性
        Field[] declaredFields = classinfo.getDeclaredFields();
        for(Field f:declaredFields){
            //3.判断是否有@ExtResource注解
            ExtResource res= f.getAnnotation(ExtResource.class);
            if(null!=res){
                //4.获取属性名称
                String name=f.getName();
                //5.从bean容器中获取bean
                Object bean=beanMap.get(name);
                if(null!=bean){
                    //6.私有访问允许访问
                    f.setAccessible(true);
                    f.set(obj,bean);
                }
            }

        }
    }

    //循环查找所有类是否有ExtService注解，有则使用反射机制初始化对象
    public ConcurrentHashMap<String, Object> findClassExtService(List<Class<?>> list) throws IllegalAccessException, InstantiationException {
        beanMap=new ConcurrentHashMap<String, Object>();
        for(Class<?> class1:list){
            //获取类的注解信息
            ExtService annotation = class1.getAnnotation(ExtService.class);
            if(null!=annotation){
                //获取service的名称
                String beanId=annotation.value();
                //如果service名称为空则使用类名(首字母小写)
                if(StringUtils.isEmpty(beanId)) beanId=toLowerCaseFirstOne(class1.getSimpleName());
                beanMap.put(beanId,class1.newInstance());
                continue;
            }
        }
        return beanMap;
    }

    // 首字母转小写
    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();
    }

}

//获取包名下所有类 的工具类
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
	 * 
	 * @param pack
	 * @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();
				}
			}
		}
	}
}