Pretender realizar la inyección de Bean en Spring a través del análisis DOM
1. Requisitos del caso
Para crear objetos en forma de reflexión, siempre que se pase la configuración xml, usamos DOM para analizar xml para leer los datos, crear objetos y asignaciones de atributos simples basadas en los datos. Este caso es para comprender mejor el contenedor IOC en Spring.
Este artículo hace referencia a la publicación del blog: Explicación detallada del análisis DOM del análisis XML
Segundo, análisis paso a paso
- Crear clase de entidad
- Crear archivo application.xml
- Analizar el archivo xml
- Crea objetos de frijol basados en la reflexión
- Asignar los datos del nodo de propiedad en la configuración xml al bean creado
- prueba
Tres, implementación de código
1. Crea una clase de entidad
El método establecido de esta clase de entidad debe ser Object, ¡porque no sabemos qué tipo de archivo se lee desde xml!
public class Student {
private int sid;
private String name;
private String sex;
public Student() {
super();
}
public Student(int sid, String name, String sex) {
super();
this.sid = sid;
this.name = name;
this.sex = sex;
}
// 注意:所有set方法的参收都要是Object类型的，这里需要强转一下
public int getSid() {
return sid;
}
public void setSid(Object sid) {
this.sid = Integer.parseInt(sid.toString());
}
public String getName() {
return name;
}
public void setName(Object name) {
this.name = (String) name;
}
public String getSex() {
return sex;
}
public void setSex(Object sex) {
this.sex = (String) sex;
}
@Override
public String toString() {
return "Student [sid=" + sid + ", name=" + name + ", sex=" + sex + "]";
}
}
2. Cree el archivo ApplicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean name="student" class="model.Student">
<property name="sid" value="001"></property>
<property name="name" value="name"></property>
<property name="sex" value="男"></property>
</bean>
</beans>
3. Analice el archivo xml, cree un objeto y asigne un valor al objeto.
Esta clase se analiza paso a paso a través de anotaciones, ¡puedes echar un vistazo más de cerca a las anotaciones!
public class MyApplicationContext{
// 使用多线程赋值的话建议使用ConcurrentHashMap
// private Map<String,Object> beansHolder = new ConcurrentHashMap<String, Object>();
private Map<String,Object> beansMap = new HashMap<String, Object>();
private String xmlPath;
public MyApplicationContext(String xmlPath) {
this.xmlPath = xmlPath;
analysisXML();
}
// DOM解析xml
public void analysisXML() {
// 找了一个工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {
// 工厂里的一个工人
DocumentBuilder buider = factory.newDocumentBuilder();
// 工人去读取xml文件 ,然后得到了一个读取到的文件
Document document = buider.parse(xmlPath);
// 读取所有bean节点
NodeList nodeBean = document.getElementsByTagName("bean");
// 循环遍历nodeBean
for(int i = 0; i < nodeBean.getLength();i++) {
// 得到所有bean属性
NamedNodeMap namedNodeMap = nodeBean.item(i).getAttributes();
// 获取bean节点
Element element = (Element)nodeBean.item(i);
// 获取bean节点下所有property元素
NodeList childNodes = element.getElementsByTagName("property");
// 将获取到的bean所有属性和bean节点下所有property元素传递到创建bean方法中继续使用
createBean(namedNodeMap,childNodes);
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 创建bean
public void createBean(NamedNodeMap namedNodeMap,NodeList childNodes) {
String className = null; // bean节点中的name属性值
String class_val = null; // bean节点中的class属性值
// 遍历bean的所有属性
for(int i = 0; i < namedNodeMap.getLength();i++) {
Node node = namedNodeMap.item(i);
// 取出name属性值
if("name".equalsIgnoreCase(node.getNodeName())) {
className = node.getNodeValue();
}
// 取出class属性值
if("class".equals(node.getNodeName())){
class_val = node.getNodeValue();
}
// 判断二者都不为空
if(!"".equals(className) && !"".equals(class_val)) {
// 去创建bean，并存入map集合
setBean(className,class_val);
}else {
System.out.println("参数为空！");
}
}
// 属性赋值（bean节点下所有property元素，bean的class属性值，bean的name属性值）
setProperty(childNodes,class_val,className);
}
// 注入属性值
public void setProperty(NodeList childNodes,String class_val,String className) {
String name_val = null; //property元素中的name属性值
Object value_val = null; //property元素中的value属性值
// 遍历所有property元素
for(int i = 0; i < childNodes.getLength();i++) {
// 获取每个property所有属性
NamedNodeMap attributes = childNodes.item(i).getAttributes();
// 遍历property的所有属性
for(int j = 0; j < attributes.getLength();j++) {
// 得到一个属性节点
Node node = attributes.item(j);
if(node!= null) {
// 得到name的值
if("name".equals(node.getNodeName())) {
name_val = node.getNodeValue();
}
// 得到value的值
if("value".equals(node.getNodeName())){
value_val = node.getNodeValue();
}
}
}
try {
// 根据bean的class属性值，获取指定类的构造器
Class<?> clazz = Class.forName(class_val);
// 去查找set方法，传入参数类型
Method method = clazz.getMethod("set"+toFirst(name_val),Object.class);
// 然后去执行set方法，指定实体类，传入该方法所需的参数
method.invoke(beansMap.get(className),value_val);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 首字母大写
public String toFirst(String str) {
if(str!=null&&str.length()>0){
str=str.substring(0, 1).toUpperCase() + str.substring(1);
}
return str;
}
// 注入bean
public void setBean(String beanNname,String clazzPath) {
try {
// 通过反射创建bena对象
Object obj = Class.forName(clazzPath).newInstance();
// 将创建的bean存入map集合
beansMap.put(beanNname,obj);
} catch (Exception e) {
e.printStackTrace();
}
}
// 获取bean对象
public Object getBean(String beanName) {
return beansMap.get(beanName);
}
}
3. Prueba
public class MainTest {
public static void main(String[] args) {
MyApplicationContext context = new MyApplicationContext("src/application.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
}
}
