Spring IoC 容器的实现原理：工厂模式 + 解析XML + 反射机制
我们给自己的框架起名为：mySpring（我的春天）
一、创建 mySpring 模块
引入dom4j 和 jaxen 的依赖，因为要使用它解析XML文件，还有 junit 依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.myspringframework</groupId>
<artifactId>mySpring</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.1.3</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.2.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
二、准备要管理的 Bean
准备好我们要管理的Bean（这些Bean在将来开发完框架之后是要删除的）
注意包名，不要用org.myspringframework包，因为这些Bean不是框架内置的。是将来使用我们框架的程序员提供的
package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-11:07
* @since 1.0
*/
public class User {
private String name;
private int age;
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-11:08
* @since 1.0
*/
public class UserDao {
public void insert(){
System.out.println("mysql数据库正在保存用户数据.......");
}
}package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-11:09
* @since 1.0
*/
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save(){
userDao.insert();
}
}
三、准备 myspring.xml 配置文件
将来在框架开发完毕之后，这个文件也是要删除的。因为这个配置文件的提供者应该是使用这个框架的程序员
文件名随意，我们这里叫做：myspring.xml
文件放在类路径当中即可，我们这里把文件放到类的根路径下
<?xml version="1.0" encoding="UTF-8"?>
<!-- 这个配置文件是使用 mySpring 框架的开发人员提供的 -->
<beans>
<bean id="user" class="org.qiu.myspring.bean.User">
<property name="name" value="张三"></property>
<property name="age" value="35"></property>
</bean>
<bean id="userDaoBean" class="org.qiu.myspring.bean.UserDao"/>
<bean id="userService" class="org.qiu.myspring.bean.UserService">
<property name="userDao" ref="userDaoBean"/>
</bean>
</beans>使用value给简单属性赋值。使用ref给非简单属性赋值。
四、编写 ApplicationContext 接口
ApplicationContext 接口中提供一个 getBean() 方法，通过该方法可以获取 Bean 对象。
注意包名：这个接口就是 myspring 框架中的一员了。
package org.myspringframework.core;
/**
* Spring 应用上下文接口
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.myspringframework.core
* @date 2022-11-12-11:22
* @since 1.0
*/
public interface ApplicationContext {
/**
* 根据 beanName 获取 bean 对象
* @param beanName myspring 配置文件中 bean 标签的 id
* @return 对应的单例 bean 对象
*/
Object getBean(String beanName);
}
五、编写 ClassPathXmlApplicationContext
ClassPathXmlApplicationContext 是 ApplicationContext 接口的实现类。该类从类路径当中加载myspring.xml 配置文件
package org.myspringframework.core;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.myspringframework.core
* @date 2022-11-12-11:24
* @since 1.0
*/
public class ClassPathXmlApplicationContext implements ApplicationContext{
/**
* 解析 myspring 配置文件，初始化所有的 bean 对象
* @param configLocation spring 配置文件的路径
* （使用 ClassPathXmlApplicationContext 配置文件应当放到类路径下）
*/
public ClassPathXmlApplicationContext(String configLocation) {
}
@Override
public Object getBean(String beanName) {
return null;
}
}
六、确定采用 Map 集合存储 Bean
确定采用Map集合存储Bean实例
Map集合的key存储beanId，value存储Bean实例。Map<String,Object>
在ClassPathXmlApplicationContext类中添加Map<String,Object>属性
并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件
同时实现getBean方法
package org.myspringframework.core;
import java.util.HashMap;
import java.util.Map;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.myspringframework.core
* @date 2022-11-12-11:24
* @since 1.0
*/
public class ClassPathXmlApplicationContext implements ApplicationContext{
private Map<String, Object> singletonObjects = new HashMap<>();
/**
* 解析 myspring 配置文件，初始化所有的 bean 对象
* @param configLocation spring 配置文件的路径
* （使用 ClassPathXmlApplicationContext 配置文件应当放到类路径下）
*/
public ClassPathXmlApplicationContext(String configLocation) {
// 解析 myspring.xml 配置文件，实例化 bean，将 bean 存放到 singletonObjects 集合中
}
/**
* 根据 beanName 在 singletonObjects 集合中获取对应的 bean 对象
* @param beanName myspring 配置文件中 bean 标签的 id
* @return 对应的 bean 对象
*/
@Override
public Object getBean(String beanName) {
return singletonObjects.get(beanName);
}
}
七、解析配置文件实例化所有 Bean
在ClassPathXmlApplicationContext 的构造方法中解析配置文件，获取所有 bean 的类名，通过反射机制调用无参数构造方法创建 Bean。并且将 Bean 对象存放到 Map 集合中
/**
* 解析 myspring 配置文件，初始化所有的 bean 对象
* @param configLocation spring 配置文件的路径
* （使用 ClassPathXmlApplicationContext 配置文件应当放到类路径下）
*/
public ClassPathXmlApplicationContext(String configLocation) {
try {
// 解析 myspring.xml 配置文件，实例化 bean，将 bean 存放到 singletonObjects 集合中
// dom4j 解析 XML 文件的核心对象
SAXReader reader = new SAXReader();
// 获取一个输入流，指向配置文件
InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
// 读文件
Document document = reader.read(in);
// 获取所有的 bean 标签
List<Node> nodes = document.selectNodes("//bean");
// 遍历 bean 标签
nodes.forEach(node -> {
try {
// 向下转型，为了使用 Element 接口中更丰富的方法
Element beanElement = (Element) node;
// 获取 id 属性
String id = beanElement.attributeValue("id");
// 获取 class 属性
String className = beanElement.attributeValue("class");
logger.info("bean id:" + id + ",bean className:" + className);
// 使用反射机制创建对象，并存储到 Map 集合中，提前曝光
Class<?> clazz = Class.forName(className);
Object bean = clazz.newInstance();
singletonObjects.put(id,bean);
// 记录日志
logger.info(singletonObjects.toString());
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
八、测试能否获取到 Bean
@Test
public void testMySpring(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
Object user = applicationContext.getBean("user");
Object userDao = applicationContext.getBean("userDaoBean");
Object userService = applicationContext.getBean("userService");
System.out.println(user);
System.out.println(userDao);
System.out.println(userService);
}运行结果：
九、给 Bean 的属性赋值
通过反射机制调用 set 方法，给 Bean 的属性赋值
package org.myspringframework.core;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.myspringframework.core
* @date 2022-11-12-11:24
* @since 1.0
*/
public class ClassPathXmlApplicationContext implements ApplicationContext{
private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
private Map<String, Object> singletonObjects = new HashMap<>();
/**
* 解析 myspring 配置文件，初始化所有的 bean 对象
* @param configLocation spring 配置文件的路径
* （使用 ClassPathXmlApplicationContext 配置文件应当放到类路径下）
*/
public ClassPathXmlApplicationContext(String configLocation) {
try {
// 解析 myspring.xml 配置文件，实例化 bean，将 bean 存放到 singletonObjects 集合中
// dom4j 解析 XML 文件的核心对象
SAXReader reader = new SAXReader();
// 获取一个输入流，指向配置文件
InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
// 读文件
Document document = reader.read(in);
// 获取所有的 bean 标签
List<Node> nodes = document.selectNodes("//bean");
// 遍历 bean 标签
nodes.forEach(node -> {
try {
// 向下转型，为了使用 Element 接口中更丰富的方法
Element beanElement = (Element) node;
// 获取 id 属性
String id = beanElement.attributeValue("id");
// 获取 class 属性
String className = beanElement.attributeValue("class");
logger.info("bean id:" + id + ",bean className:" + className);
// 使用反射机制创建对象，并存储到 Map 集合中，提前曝光
Class<?> clazz = Class.forName(className);
Object bean = clazz.newInstance();
singletonObjects.put(id,bean);
// 记录日志
logger.info(singletonObjects.toString());
} catch (Exception e) {
e.printStackTrace();
}
});
nodes.forEach(node -> {
try {
Element beanElement = (Element) node;
// 获取 id 属性
String id = beanElement.attributeValue("id");
// 获取 class 属性
String className = beanElement.attributeValue("class");
// 获取 Class
Class<?> clazz = Class.forName(className);
// 获取该 bean 标签下的所有 属性标签 property 标签
for (Element property : beanElement.elements("property")) {
// 获取属性名
String propertyName = property.attributeValue("name");
// 获取属性类型
Field field = clazz.getDeclaredField(propertyName);
logger.info("属性名：" + propertyName);
// 获取 set 方法名
String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
// 获取 set 方法
Method setMethod = clazz.getDeclaredMethod(setMethodName, field.getType());
// 获取具体的值
String value = property.attributeValue("value");
String ref = property.attributeValue("ref");
Object realVal = null;
// 值是简单类型
if (value != null) {
/**
* 声明支持的简单类型
* byte short int long float double boolean char
* Byte Short Integer Long Float Double Boolean Character
* String
*/
// 属性类型名
// String propertyTypeSimpleName = field.getType().getName(); 带有包名
String propertyTypeSimpleName = field.getType().getSimpleName();
switch (propertyTypeSimpleName){
case "byte":
realVal = Byte.parseByte(value);
break;
case "short":
realVal = Short.parseShort(value);
break;
case "int":
realVal = Integer.parseInt(value);
break;
case "long":
realVal = Long.parseLong(value);
break;
case "float":
realVal = Float.parseFloat(value);
break;
case "double":
realVal = Double.parseDouble(value);
break;
case "boolean":
realVal = Boolean.parseBoolean(value);
break;
case "char":
realVal = value.charAt(0);
break;
case "Byte":
realVal = Byte.valueOf(value);
break;
case "Short":
realVal = Short.valueOf(value);
break;
case "Integer":
realVal = Integer.valueOf(value);
break;
case "Long":
realVal = Long.valueOf(value);
break;
case "Float":
realVal = Float.valueOf(value);
break;
case "Double":
realVal = Double.valueOf(value);
break;
case "Boolean":
realVal = Boolean.valueOf(value);
break;
case "Character":
realVal = Character.valueOf(value.charAt(0));
break;
case "String":
realVal = value;
break;
}
// 调用 set 方法
setMethod.invoke(singletonObjects.get(id), realVal);
}
// 值是非简单类型
if (ref != null) {
// 调用 set 方法
setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
}
}
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 根据 beanName 在 singletonObjects 集合中获取对应的 bean 对象
* @param beanName myspring 配置文件中 bean 标签的 id
* @return 对应的 bean 对象
*/
@Override
public Object getBean(String beanName) {
return singletonObjects.get(beanName);
}
}@Test
public void testMySpring(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
Object user = applicationContext.getBean("user");
System.out.println(user);
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();
}运行结果：
十、打包发布
将多余的类以及配置文件删除，使用 maven 打包发布
十一、站在程序员角度使用 mySpring 框架
<dependencies>
<dependency>
<groupId>org.myspringframework</groupId>
<artifactId>mySpring</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-14:43
* @since 1.0
*/
public class Vip {
private String name;
private int age;
private double height;
@Override
public String toString() {
return "Vip{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setHeight(double height) {
this.height = height;
}
}package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-14:43
* @since 1.0
*/
public class OrderDao {
public void insert(){
System.out.println("正在保存订单信息......");
}
}package org.qiu.myspring.bean;
/**
* @author 秋玄
* @version 1.0
* @email qiu_2022@aliyun.com
* @project Spring
* @package org.qiu.myspring.bean
* @date 2022-11-12-14:44
* @since 1.0
*/
public class OrderService {
private OrderDao orderDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
public void generate(){
orderDao.insert();
}
}<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="vip" class="org.qiu.myspring.bean.Vip">
<property name="name" value="张三丰"/>
<property name="age" value="120"/>
<property name="height" value="1.82"/>
</bean>
<bean id="orderDao" class="org.qiu.myspring.bean.OrderDao"/>
<bean id="orderService" class="org.qiu.myspring.bean.OrderService">
<property name="orderDao" ref="orderDao"/>
</bean>
</beans>@Test
public void testMySpring(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
Object vip = applicationContext.getBean("vip");
System.out.println(vip);
OrderService orderService = (OrderService) applicationContext.getBean("orderService");
orderService.generate();
}运行结果：
一 叶 知 秋，奥 妙 玄 心
