在上一篇当中我们完成了对三种资源文件的读写
上篇内容：Spring是如何实现资源文件的加载
@Test
public void testClassPathResource() throws IOException {
DefaultResourceLoader defaultResourceLoader = new DefaultResourceLoader();
Resource resource = defaultResourceLoader.getResource("classpath:hello.txt");
InputStream inputStream = resource.getInputStream();
String read = IoUtil.readUtf8(inputStream);
System.out.println(read);
}
对于单一的资源文件我们要想将其中的配置解析为Bean需要经过以上几步
- 获取默认的资源文件加载器
- 加载指定资源文件
- 获取输入流对象
- 解析为Bean
如何解析XML文件
将XML文件配置解析为BeanDefinition，需要涉及到的有BeanDefinition的注册功能与ResourceLoad资源文件加载器
这里我们就可以定义一个类，同时实现以上两者
首先为了扩展性我们先定义一个BeanDefinitionReader接口，我们来想一下不只是XML方式来注册Bean，在Spring当中还可以通过注解等方式，那我们就需要抽象一个通用接口定义通用方法，供子类来实现就行了
public interface BeanDefinitionReader {
/**
* 获取BeanDefinitionRegister实例。
* @return BeanDefinitionRegister 用于注册BeanDefinition的实例
*/
BeanDefinitionRegister getRegistry();
/**
* 获取ResourceLoader实例。
* @return ResourceLoader 用于加载资源的实例
*/
ResourceLoader getResourceLoad();
/**
* 根据指定的资源位置加载BeanDefinition。
* @param location 资源的位置，通常为文件路径或URL
*/ void loadBeanDefinitions(String location);
/**
* 根据指定的多个资源位置加载BeanDefinition。
* @param locations 资源的位置数组，通常为文件路径或URL数组
*/
void loadBeanDefinitions(String[] locations);
/**
* 根据指定的Resource对象加载BeanDefinition。
* @param resource 资源对象，包含具体的资源信息
*/
void loadBeanDefinitions(Resource resource);
}
之后我们还可以定义一个抽象类，实现通用方法的基本逻辑
public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader{
private ResourceLoader resourceLoader;
private final BeanDefinitionRegister beanDefinitionRegister;
/**
* beanDefinitionRegister是用来注册BeanDefinition使用的
* 其子类DefaultListableBeanFactory实现了beanDefinitionRegister与BeanFactory
* 可以通过DefaultListableBeanFactory获取、创建Bean
* @param beanDefinitionRegister 用于注册BeanDefinition的实例
*/
protected AbstractBeanDefinitionReader(BeanDefinitionRegister beanDefinitionRegister) {
this.resourceLoader = new DefaultResourceLoader();
this.beanDefinitionRegister = beanDefinitionRegister;
}
/**
* 根据指定的多个资源位置加载BeanDefinition。
*
* @param locations 资源的位置数组，通常为文件路径或URL数组
*/
@Override
public void loadBeanDefinitions(String[] locations) {
for (String location : locations) {
loadBeanDefinitions(location);
}
}
/**
* 获取BeanDefinitionRegister实例。
*
* @return BeanDefinitionRegister 用于注册BeanDefinition的实例
*/
@Override
public BeanDefinitionRegister getRegistry() {
return beanDefinitionRegister;
}
/**
* 获取ResourceLoader实例。
*
* @return ResourceLoader 用于加载资源的实例
*/
@Override
public ResourceLoader getResourceLoad() {
return resourceLoader;
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
}
现在我们就可以完成对于XML文件的具体解析逻辑了
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
public static final String BEAN_ELEMENT = "bean";
public static final String PROPERTY_ELEMENT = "property";
public static final String ID_ATTRIBUTE = "id";
public static final String NAME_ATTRIBUTE = "name";
public static final String CLASS_ATTRIBUTE = "class";
public static final String VALUE_ATTRIBUTE = "value";
public static final String REF_ATTRIBUTE = "ref";
/**
* beanDefinitionRegister是用来注册BeanDefinition使用的
* 其子类DefaultListableBeanFactory实现了beanDefinitionRegister与BeanFactory
* 可以通过DefaultListableBeanFactory获取、创建Bean
* * @param beanDefinitionRegister 用于注册BeanDefinition的实例
*/
public XmlBeanDefinitionReader(BeanDefinitionRegister beanDefinitionRegister) {
super(beanDefinitionRegister);
}
/**
* 根据指定的资源位置加载BeanDefinition。
*
* @param location 资源的位置，通常为文件路径或URL
*/ @Override
public void loadBeanDefinitions(String location) {
// 通过ResourceLoad获取到Resource
ResourceLoader resourceLoad = getResourceLoad();
Resource resource = resourceLoad.getResource(location);
this.loadBeanDefinitions(resource);
}
/**
* 根据指定的Resource对象加载BeanDefinition。
*
* @param resource 资源对象，包含具体的资源信息
*/
@Override
public void loadBeanDefinitions(Resource resource) {
try {
InputStream inputStream = resource.getInputStream();
try {
doLoadBeanDefinitions(inputStream);
}finally {
inputStream.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected void doLoadBeanDefinitions(InputStream inputStream) throws Exception {
Document document = XmlUtil.readXML(inputStream);
Element root = document.getDocumentElement();
NodeList childNodes = root.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
if (childNodes.item(i) instanceof Element) {
if (BEAN_ELEMENT.equals(((Element) childNodes.item(i)).getNodeName())) {
//解析bean标签
Element bean = (Element) childNodes.item(i);
String id = bean.getAttribute(ID_ATTRIBUTE);
String name = bean.getAttribute(NAME_ATTRIBUTE);
String className = bean.getAttribute(CLASS_ATTRIBUTE);
Class<?> clazz = Class.forName(className);
//id优先于name
String beanName = StrUtil.isNotEmpty(id) ? id : name;
if (StrUtil.isEmpty(beanName)) {
//如果id和name都为空，将类名的第一个字母转为小写后作为bean的名称
beanName = StrUtil.lowerFirst(clazz.getSimpleName());
}
BeanDefinition beanDefinition = new BeanDefinition(clazz);
for (int j = 0; j < bean.getChildNodes().getLength(); j++) {
if (bean.getChildNodes().item(j) instanceof Element) {
if (PROPERTY_ELEMENT.equals(((Element) bean.getChildNodes().item(j)).getNodeName())) {
//解析property标签
Element property = (Element) bean.getChildNodes().item(j);
String nameAttribute = property.getAttribute(NAME_ATTRIBUTE);
String valueAttribute = property.getAttribute(VALUE_ATTRIBUTE);
String refAttribute = property.getAttribute(REF_ATTRIBUTE);
Object value = valueAttribute;
if (StrUtil.isNotEmpty(refAttribute)) {
value = new BeanReference(refAttribute);
}
PropertyValue propertyValue = new PropertyValue(nameAttribute, value);
beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
}
}
}
getRegistry().registerBeanDefinition(beanName, beanDefinition);
}
}
}
}
}
写一个测试来实现该逻辑
@Test
public void testXmlResourceReader(){
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(factory);
xmlBeanDefinitionReader.loadBeanDefinitions("classpath:spring.xml");
People person = (People) factory.getBean("person");
System.out.println(person);
}