手写springiocxml方式注入对象

什么是SpringIOC
spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
交由Spring来管理这些，实现解耦
SpringIOC原理
使用反射机制+XML技术

 

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
     	 
	
	<!-- 把对象初始化之后,存在HashMap里面去 
		放到内存里面去,JVM内存里面去之后,别人只要调用getBean方法之后,去Spring的容器里面去找到一个对象就行了
		这种方式也可以,这种方式我待会再讲,再讲注解的时候我会去实现,所以我是把两种方式都会实现的,待会我讲注解方式的时候会
		详细讲的,在Spring中id如果重复的情况下是会报错的,所以有的时候是需要做校验的,找最后默认的也可以,这个看你自己
		怎么实现,
	-->
	<bean id="user" class="com.learn.spring.entity.User"></bean>
	
</beans>

package com.learn.spring.entity;

public class User {

	private Integer id;
	private String userName;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

}

package com.learn.spring;

import java.io.InputStream;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 我们先定义这个类
 * 我会将两种方式的实现方式
 * 我们建完ClassPathXmlApplicationContext这个类
 * 自定义Spring容器框架
 * xml方式实现
 * 你们在写代码之前
 * 不要盲目的去写
 * 先通过白话文
 * 他不知道思路
 * 你先通过白话文知道整个实现过程
 * 那这个我们怎么实现呢
 * 
 * 
 * @author Leon.Sun
 *
 */
public class ClassPathXmlApplicationContext {
	// xml路径地址
	/**
	 * xml读取路径地址
	 * 
	 */
	private String xmlPath;

	/**
	 * 定义一个构造函数
	 * 传入xmlPath
	 * 
	 * 
	 * @param xmlPath
	 */
	public ClassPathXmlApplicationContext(String xmlPath) {
		this.xmlPath = xmlPath;
	}

	/**
	 * 这里要传入一个bean的id过来
	 * 返回的是一个Object对象
	 * 这个方法也返回Object对象
	 * 
	 * 
	 * @param beanId
	 * @return
	 * @throws Exception
	 */
	public Object getBean(String beanId) throws Exception {
		// 1. 读取配置文件
		/**
		 * 解析XML文件
		 * 如果不解析
		 * 我怎么去读取这个bean
		 * 是不是这样的
		 * 这肯定要解析
		 * 解析是第一步
		 * 第一步是把XML文件解析一遍
		 * 
		 */
		List<Element> elements = readerXml();
		/**
		 * 还有一种场景就是我没有配置任何bean
		 * 代码根本就不用往下面再走了
		 * 是不是这样的
		 * 我们是不是可以直接判断一下
		 * 
		 */
		if (elements == null) {
			throw new Exception("该配置文件没有子元素");
		}
		// 2. 使用beanId查找对应的class地址
		/**
		 * 我把xml全部解析了之后
		 * 第二步干嘛
		 * 使用方法参数bean id查找配置文件中bean节点的id信息是否一致
		 * 假设我这个时候传入userService
		 * 这样的一个beanid
		 * 查找到了就要获取他的class地址
		 * 是不是这样的
		 * 然后方法里面传入一个参数过来userService
		 * 我能不能找到userService的一个节点
		 * 是不是找到这个节点
		 * 
		 * 
		 */
		String beanClass = findXmlByIDClass(elements, beanId);
		if (StringUtils.isEmpty(beanClass)) {
			throw new Exception("未找到对应的class地址");
		}
		// 3. 使用反射机制初始化，对象
		/**
		 * 获取class信息地址
		 * 使用反射机制初始化
		 * 
		 * 找到class信息
		 * 拿到信息之后我使用JAVA的反射机制
		 * 初始化之后返回给调用者
		 * 这里有多少个实现方式
		 * 
		 * 
		 */
		Class<?> forName = Class.forName(beanClass);
		return forName.newInstance();
	}

	// 读取配置文件信息
	/**
	 * 表示解析这样的一个XML
	 * 这个传入的可以没有
	 * 因为它直接拿全局的
	 * 这个大家一定要慢慢的去想
	 * 这个讲的非常细
	 * 
	 * 解析XML文件信息
	 * 拿到每个节点的信息
	 * 拿到每个文件信息以后
	 * 传入一个bean的ID去里面去找
	 * 进行反射去实现出来
	 * 你们可以先把这些节点信息给他封装起来
	 * 怎么封装呢
	 * 
	 * 
	 * @return
	 * @throws DocumentException
	 */
	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();
		// 获取子节点
		/**
		 * 获取根节点下的所有的子节点
		 * 获取这样的一个子节点之后
		 * 获取项目下的所有的子节点
		 * 获取所有子节点element的对象
		 * 获取完了之后我们再怎么进行实现呢
		 * 这个时候我可以拿到所有的bean的节点
		 * 
		 */
		List<Element> elements = rootElement.elements();
		/**
		 * 就是判断是否为空
		 * 
		 */
		if (elements == null || elements.isEmpty()) {
			return null;
		}
		return elements;
	}

	// 使用beanid查找该Class地址
	/**
	 * 是用beanid去查找有没有这样的class地址
	 * 我们是不是要调用根节点
	 * 
	 * 
	 * 
	 * @param elements
	 * @param beanId
	 * @return
	 * @throws Exception
	 */
	public String findXmlByIDClass(List<Element> elements, String beanId) throws Exception {
		for (Element element : elements) {
			// 读取节点上是否有value
			/**
			 * 获取属性的信息
			 * 这个id就表示当前的userService
			 * 
			 * 
			 */
			String beanIdValue = element.attributeValue("id");
			/**
			 * 如果xml的id等于空的情况下
			 * 就结束当前循环
			 * 你如果使用Spring的时候
			 * 会校验的
			 * 这个具体看你们自己
			 * 
			 */
			if (beanIdValue == null) {
				throw new Exception("使用该beanId为查找到元素");
			}
			if (!beanIdValue.equals(beanId)) {
				/**
				 * 结束本次循环
				 * 
				 */
				continue;
			}
			// 获取Class地址属性
			/**
			 * 拿到这样的一个class地址
			 * 拿到之后
			 * 然后用反射去做一个初始化过程
			 * 
			 */
			String classPath = element.attributeValue("class");
			/**
			 * 如果等于null的情况下它会怎么样
			 * 
			 */
			if (!StringUtils.isEmpty(classPath)) {
				return classPath;
			}
		}
		return null;
	}

	// 读取xml配置文件
	/**
	 * 获取当前上下文路径
	 * 
	 * @param xmlPath
	 * @return
	 */
	public InputStream getClassXmlInputStream(String xmlPath) {
		InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(xmlPath);
		return resourceAsStream;
	}

}

package com.learn.spring;

import com.learn.spring.entity.User;

public class Test002 {

	public static void main(String[] args) throws Exception {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
		User user = (User) applicationContext.getBean("user");
		System.out.println(user);
	}

}