chapter05_从spring.xml读取Bean - 教程
一、简化Bean的注册
如果每次注册一个Bean，都要像上节一样，手动写PropertyValues相关的代码，那太复杂了，我们希望读取XML文件，自动注册Bean，这样对于使用者，甚至不知道有BeanDefinition的存在
二、统一处理资源文件
新建资源接口，Spring对所有的资源文件，统一处理
- 一个资源，最重要的就是拿到输入流，拿到输入流就可以读取文件
public interface Resource {
InputStream getInputStream() throws IOException;
}提供三个资源实现类，分别读取不同类型的文件，这就是策略模式
类路径下的文件（最常用）
public class ClassPathResource
implements Resource{
private final String path;
private final ClassLoader classLoader;
public ClassPathResource(String path) {
this(path, null);
}
public ClassPathResource(String path, ClassLoader classLoader) {
Assert.notNull(path, "Path must not be null");
this.path = path;
this.classLoader = classLoader != null ? classLoader : ClassUtil.getClassLoader();
}
@Override
public InputStream getInputStream() throws IOException {
InputStream is = classLoader.getResourceAsStream(path);
if (is == null) {
throw new FileNotFoundException(path + " cannot be opened because it does not exist");
}
return is;
}
}文件系统下的文件
public class FileSystemResource
implements Resource{
private File file;
public FileSystemResource(File file) {
this.file = file;
}
@Override
public InputStream getInputStream() throws IOException {
return Files.newInputStream(file.toPath());
}
}网络文件
public class UrlResource
implements Resource{
private final URL url;
public UrlResource(URL url) {
Assert.notNull(url,"URL must not be null");
this.url = url;
}
@Override
public InputStream getInputStream() throws IOException {
URLConnection con = url.openConnection();
return con.getInputStream();
}
}资源加载器接口，简化资源类的使用，自动根据路径选择合适的加载类
- 这又属于工厂方法设计模式
/**
* @Author 孤风雪影
* @Email gitee.com/efairy520
* @Date 2025/1/2 22:16
* @Version 1.0
*/
public interface ResourceLoader {
String CLASSPATH_URL_PREFIX = "classpath:";
Resource getResource(String location);
}资源加载器接口实现
- 根据路径前缀，默认就是使用classpath策略
/**
* @Author 孤风雪影
* @Email gitee.com/efairy520
* @Date 2025/1/2 22:18
* @Version 1.0
*/
public class DefaultResourceLoader
implements ResourceLoader{
@Override
public Resource getResource(String location) {
Assert.notNull(location, "Location must not be null");
if (location.startsWith(CLASSPATH_URL_PREFIX)) {
//使用类路径加载器，去掉前缀
return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()));
}
else {
try {
URL url = new URL(location);
return new UrlResource(url);
} catch (MalformedURLException e) {
return new FileSystemResource(new File(location));
}
}
}
}三、从文件中读取Bean
定义BeanDefinitionReader接口，从文件中读取BeanDefinition，并且注册到Bean工厂，这里有三要素
- 资源文件
- Bean工厂
- 读取BeanDefinition的逻辑（单个资源，多个资源，位置字符串）
/**
* @Author 孤风雪影
* @Email gitee.com/efairy520
* @Date 2025/1/2 22:26
* @Version 1.0
*/
public interface BeanDefinitionReader {
BeanDefinitionRegistry getRegistry();
ResourceLoader getResourceLoader();
void loadBeanDefinitions(Resource resource);
void loadBeanDefinitions(Resource... resources);
void loadBeanDefinitions(String location);
}用抽象类AbstractBeanDefinitionReader实现接口，模板方法设计模式
- Bean工厂和资源加载器都是确定的，抽象类直接实现
- 只有加载BeanDefinition是不确定的逻辑，交给具体的策略子类实现
public abstract class AbstractBeanDefinitionReader
implements BeanDefinitionReader {
private final BeanDefinitionRegistry registry;
private final ResourceLoader resourceLoader;
public AbstractBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
this.registry = registry;
this.resourceLoader = resourceLoader;
}
public AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, new DefaultResourceLoader());
}
@Override
public BeanDefinitionRegistry getRegistry() {
return registry;
}
@Override
public ResourceLoader getResourceLoader() {
return resourceLoader;
}
}XmlBeanDefinitionReader做具体实现，策略模式
public class XmlBeanDefinitionReader
extends AbstractBeanDefinitionReader {
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
super(registry, resourceLoader);
}
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) {
super(registry);
}
@Override
public void loadBeanDefinitions(Resource resource) {
try {
InputStream is = resource.getInputStream();
doLoadBeanDefinitions(is);
} catch (IOException e) {
throw new RuntimeException("IOException parsing XML document from " + resource, e);
}
}
@Override
public void loadBeanDefinitions(Resource... resources) {
for (Resource resource : resources) {
loadBeanDefinitions(resource);
}
}
@Override
public void loadBeanDefinitions(String location) {
ResourceLoader resourceLoader = getResourceLoader();
Resource resource = resourceLoader.getResource(location);
loadBeanDefinitions(resource);
}
/**
* 真正解析XMl文件的方法
*
* @param inputStream
*/
private void doLoadBeanDefinitions(InputStream inputStream) {
Document doc = XmlUtil.readXML(inputStream);
Element root = doc.getDocumentElement();
NodeList childNodes = root.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
// 判断元素
if (!(childNodes.item(i) instanceof Element)) continue;
// 判断对象
if (!"bean".equals(childNodes.item(i).getNodeName())) continue;
// 解析标签
Element bean = (Element) childNodes.item(i);
String id = bean.getAttribute("id");
String name = bean.getAttribute("name");
String className = bean.getAttribute("class");
// 获取 Class，方便获取类中的名称
Class<
?> clazz = null;
try {
clazz = Class.forName(className);
} catch (ClassNotFoundException e) {
throw new RuntimeException("不存在的类名" + className);
}
// 优先级 id > name，此处是Bean自己的id和name
String beanName = StrUtil.isNotEmpty(id) ? id : name;
if (StrUtil.isEmpty(beanName)) {
beanName = StrUtil.lowerFirst(clazz.getSimpleName());
}
// 定义Bean
BeanDefinition beanDefinition = new BeanDefinition(clazz);
// 读取属性并填充
for (int j = 0; j < bean.getChildNodes().getLength(); j++) {
if (!(bean.getChildNodes().item(j) instanceof Element)) continue;
if (!"property".equals(bean.getChildNodes().item(j).getNodeName())) continue;
// 解析标签：property
Element property = (Element) bean.getChildNodes().item(j);
String attrName = property.getAttribute("name");
String attrValue = property.getAttribute("value");
String attrRef = property.getAttribute("ref");
// 获取属性值：引入对象、值对象
Object value = StrUtil.isNotEmpty(attrRef) ? new BeanReference(attrRef) : attrValue;
// 创建属性信息
PropertyValue propertyValue = new PropertyValue(attrName, value);
beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
}
if (getRegistry().containsBeanDefinition(beanName)) {
throw new RuntimeException("Duplicate beanName[" + beanName + "] is not allowed");
}
// 注册 BeanDefinition
getRegistry().registerBeanDefinition(beanName, beanDefinition);
}
}
}BeanDefinitionReader接口、资源接口，层次结构图
四、测试
新建Person类
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Person
{
private String name;
private int age;
private Cat cat;
}新建Cat类
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Cat
{
private String name;
private int weight;
}编写一个spring.xml文件
<
?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="cat" class=
"cn.shopifymall.springframework.test.bean.Cat">
<property name="name" value="tomcat"/>
<property name="weight" value="2000"/>
<
/bean>
<bean id="person" class=
"cn.shopifymall.springframework.test.bean.Person">
<property name="name" value="10001"/>
<property name="age" value="18"/>
<property name="cat" ref="cat"/>
<
/bean>
<
/beans>新建测试类
public class ApiTest
{
@Test
public void testGetBeanFromXml() {
// 1.初始化 BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 2. 读取配置文件&注册Bean
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
reader.loadBeanDefinitions("classpath:spring.xml");
// 3. 获取Bean对象调用方法
Person person = (Person) beanFactory.getBean("person");
System.out.println("person：" + person);
}
}控制台输出
person：Person(name=10001, age=18, cat=Cat(name=tomcat, weight=2000))五、总结
- 通过引入spring.xml配置文件，我们就可以简化Bean的注册
- 用户只需要编写一个xml文件，由XmlBeanDefinitionReader自动解析xml文件，生成BeanDefinition并注册到BeanFactory
浙公网安备 33010602011771号