目录
十一、手写Spring框架
第一步:创建模块myspring
第二步:准备好要管理的Bean
第三步:准备myspring.xml配置文件
第四步:核心接口实现
第五步:实例化Bean
第六步:给Bean属性赋值
第七步:测试
第八步:打包发布
第十一步:使用myspring框架
Spring IoC容器的实现原理:工厂模式+解析XML+反射机制。
配置pom.xml文件
4.0.0
org.myspringframework
myspring
1.0.0
jar
junit
junit
4.13.2
test
org.dom4j
dom4j
2.1.3
jaxen
jaxen
1.2.0
20
20
UTF-8
这些Bean在将来开发完框架之后是要删除的。
User
package com.hhb.myspring.bean;
public class User {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
UserDao
package com.hhb.myspring.bean;
public class UserDao {
public void insert() {
System.out.println("保存用户信息");
}
}
UserService
package com.hhb.myspring.bean;
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
userDao.insert();
}
}
将来在框架开发完毕之后,这个文件也是要删除的。
文件放在类的根路径下。
myspring.xml
使用value给简单属性赋值,使用ref给非简单属性赋值。
ApplicationContext
package org.myspringframework.core;
/**
* MySpring框架应用上下文接口。
*/
public interface ApplicationContext {
/**
* 根据bean的名称获取对象的bean对象
*
* @param beanName myspring配置文件中bean标签的id
* @return 对应的单例bean对象
*/
Object getBean(String beanName);
}
ClassPathXmlApplicationContext
package org.myspringframework.core;
import java.util.HashMap;
import java.util.Map;
public class ClassPathXmlApplicationContext implements ApplicationContext {
private Map singletonObjects = new HashMap<>();
/**
* 解析myspring的配置文件,然后初始化所有的Bean对象
*
* @param configLocation spring配置文件的路径
*/
public ClassPathXmlApplicationContext(String configLocation) {
//解析myspring.xml文件,然后实例化Bean,将Bean存放到singletonObjects集合当中
}
@Override
public Object getBean(String beanName) {
return singletonObjects.get(beanName);
}
}
ClassPathXmlApplicationContext
package org.myspringframework.core;
import org.dom4j.Document;
import org.dom4j.DocumentException;
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.Constructor;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ClassPathXmlApplicationContext implements ApplicationContext {
private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
private Map singletonObjects = new HashMap<>();
/**
* 解析myspring的配置文件,然后初始化所有的Bean对象
*
* @param configLocation spring配置文件的路径
*/
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 nodes = document.selectNodes("//bean");
// 遍历bean标签
nodes.forEach(node -> {
try {
// 向下转型的目的是为了使用Element接口里更加丰富的方法。
Element beanElt = (Element) node;
// 获取id属性
String id = beanElt.attributeValue("id");
// 获取class属性
String className = beanElt.attributeValue("class");
logger.info("beanName=" + id);
logger.info("beanClassName=" + className);
//通过反射机制创建对象,将其放到Map集合中,提前曝光
//获取Class
Class> aClass = Class.forName(className);
//获取无参数构造方法
Constructor> defaultCon = aClass.getDeclaredConstructor();
//调用无参数构造方法实例化Bean
Object bean = defaultCon.newInstance();
//将Bean曝光,加入到Map集合
singletonObjects.put(id, bean);
//记录日志
logger.info(singletonObjects.toString());
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (DocumentException e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String beanName) {
return singletonObjects.get(beanName);
}
}
package org.myspringframework.core;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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;
/**
* @author 动力节点
* @version 1.0
* @className ClassPathXmlApplicationContext
* @since 1.0
**/
public class ClassPathXmlApplicationContext implements ApplicationContext{
private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
private Map 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 nodes = document.selectNodes("//bean");
// 遍历bean标签
nodes.forEach(node -> {
try {
// 向下转型的目的是为了使用Element接口里更加丰富的方法。
Element beanElt = (Element) node;
// 获取id属性
String id = beanElt.attributeValue("id");
// 获取class属性
String className = beanElt.attributeValue("class");
logger.info("beanName=" + id);
logger.info("beanClassName="+className);
// 通过反射机制创建对象,将其放到Map集合中,提前曝光。
// 获取Class
Class> aClass = Class.forName(className);
// 获取无参数构造方法
Constructor> defaultCon = aClass.getDeclaredConstructor();
// 调用无参数构造方法实例化Bean
Object bean = defaultCon.newInstance();
// 将Bean曝光,加入Map集合
singletonObjects.put(id, bean);
// 记录日志
logger.info(singletonObjects.toString());
} catch (Exception e) {
e.printStackTrace();
}
});
// 再次重新把所有的bean标签遍历一次,这一次主要是给对象的属性赋值。
nodes.forEach(node -> {
try {
Element beanElt = (Element) node;
// 获取id
String id = beanElt.attributeValue("id");
// 获取className
String className = beanElt.attributeValue("class");
// 获取Class
Class> aClass = Class.forName(className);
// 获取该bean标签下所有的属性property标签
List propertys = beanElt.elements("property");
// 遍历所有的属性标签
propertys.forEach(property -> {
try {
// 获取属性名
String propertyName = property.attributeValue("name");
// 获取属性类型
Field field = aClass.getDeclaredField(propertyName);
logger.info("属性名:" + propertyName);
// 获取set方法名
String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
// 获取set方法
Method setMethod = aClass.getDeclaredMethod(setMethodName, field.getType());
// 获取具体的值
String value = property.attributeValue("value"); // "30"
Object actualValue = null; // 真值
String ref = property.attributeValue("ref");
if (value != null) {
// 说明这个值是简单类型
// 调用set方法(set方法没有返回值)
// 我们myspring框架声明一下:我们只支持这些类型为简单类型
// byte short int long float double boolean char
// Byte Short Integer Long Float Double Boolean Character
// String
// 获取属性类型名
String propertyTypeSimpleName = field.getType().getSimpleName();
switch (propertyTypeSimpleName) {
case "byte":
actualValue = Byte.parseByte(value);
break;
case "short":
actualValue = Short.parseShort(value);
break;
case "int":
actualValue = Integer.parseInt(value);
break;
case "long":
actualValue = Long.parseLong(value);
break;
case "float":
actualValue = Float.parseFloat(value);
break;
case "double":
actualValue = Double.parseDouble(value);
break;
case "boolean":
actualValue = Boolean.parseBoolean(value);
break;
case "char":
actualValue = value.charAt(0);
break;
case "Byte":
actualValue = Byte.valueOf(value);
break;
case "Short":
actualValue = Short.valueOf(value);
break;
case "Integer":
actualValue = Integer.valueOf(value);
break;
case "Long":
actualValue = Long.valueOf(value);
break;
case "Float":
actualValue = Float.valueOf(value);
break;
case "Double":
actualValue = Double.valueOf(value);
break;
case "Boolean":
actualValue = Boolean.valueOf(value);
break;
case "Character":
actualValue = Character.valueOf(value.charAt(0));
break;
case "String":
actualValue = value;
}
setMethod.invoke(singletonObjects.get(id), actualValue);
}
if (ref != null) {
// 说明这个值是非简单类型
// 调用set方法(set方法没有返回值)
setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
}
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String beanName) {
return singletonObjects.get(beanName);
}
}
@Test
public void test1(){
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
Object user = applicationContext.getBean("user");
System.out.println(user);
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();
}
配置pom.xml
org.myspringframework
myspring
1.0.0
junit
junit
4.13.2
test