XML建模分析

什么是XML建模

什么是xml建模：
XML建模主要是针对数据存储所开发，XML建模就是将指定的XML字符串当做对象操作，好处在于，只需要调用指定的方法就可以完成预定的字符串获取；

建模思路

1.分析需要被建模的文件中有哪几个对象：
如下config.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE config[
	<!ELEMENT config (action*)>
	<!ELEMENT action (forward*)>
	<!ELEMENT forward EMPTY>
	<!ATTLIST action
	  path CDATA #REQUIRED
	  type CDATA #REQUIRED
	>
	<!ATTLIST forward
	  name CDATA #REQUIRED
	  path CDATA #REQUIRED
	  redirect (true|false) "false"
	>
]>

<config>
	<action path="/regAction" type="test.RegAction">
		<forward name="failed" path="/reg.jsp" redirect="false" />
		<forward name="success" path="/login.jsp" redirect="true" />
	</action>

	<action path="/loginAction" type="test.LoginAction">
		<forward name="failed" path="/login.jsp" redirect="false" />
		<forward name="success" path="/main.jsp" redirect="true" />
	</action>
</config>

从代码中可以看到有三个对象需要建模,分别是：config,action,forward

2.每个对象拥有的行为以及属性
还是上面的config.xml文件：
首先是forward对象它的行为只有获取，属性是name，path，redirect（redirect属性是boolean类型(只有xml中填写了false，它才代表转发)），然后看action对象，它的行为有新增和获取两种行为，因为action对象内部forward对象有多个forward还可以增加，action属性有path，type
3、定义对象从小到大（从里到外）

4、通过23种的设计模式中的工厂模式，解析xml生产出指定对象

XML建模

forward对象

/**
 * 
 */
package com.shegx.model;

/**
 * @author SHE
 *
 * 2020年5月22日下午7:46:00
 *  com.shegx.model
 */
public class ForwardModel {

	private String name;
	private String path;
	private boolean redirect;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPath() {
		return path;
	}
	public void setPath(String path) {
		this.path = path;
	}
	public boolean isRedirect() {
		return redirect;
	}
	public void setRedirect(boolean redirect) {
		this.redirect = redirect;
	}
	
	
	
}

action对象

/**
 * 
 */
package com.shegx.model;

import java.util.HashMap;
import java.util.Map;

/**
 * @author SHE
 *
 * 2020年5月22日下午7:46:35
 *  com.shegx.model
 */
public class Actionmodel {

	private String path;
	private String type;
	//用一个map集合存储forwardmodel
	private Map<String, ForwardModel> foMap=new HashMap<>();
	public String getPath() {
		return path;
	}
	public void setPath(String path) {
		this.path = path;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}

	//两个行为
	/**
	 * 将指定的forwardModel压入当前actionModel对象中
	 * <forward>标签放入<action>中
	 * @param forwarModel
	 */
	public void push(ForwardModel forwarModel) {
		foMap.put(forwarModel.getName(), forwarModel);
	}
	
	public ForwardModel pop(String name) {
		return foMap.get(name);
	}
	
	
	
}

config对象

/**
 * 
 */
package com.shegx.model;

import java.util.HashMap;
import java.util.Map;

/**
 * @author SHE
 *
 * 2020年5月22日下午7:47:09
 *  com.shegx.model
 */
public class ConfidModel {
private Map<String, Actionmodel> acMap=new HashMap<String, Actionmodel>();
	
	
//两个行为
	/**
	 * 将指定的Actionmodel压入当前ConfidModel对象中
	 * <action>标签放入<confid>中
	 * @param Actionmodel
	 */
	public void push(Actionmodel actionModel) {
		acMap.put(actionModel.getPath(), actionModel);
	}
	
	public Actionmodel pop(String path) {
		return acMap.get(path);
	}
	
	
}

然后创建一个工厂类：

ConfigModelFactory

/**
 * 
 */
package com.shegx.model;

import java.io.InputStream;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * @author SHE
 *
 *工厂模式将代码封装，提高了代码的复用性
 *一般工厂类一定会有一个方法，就是生产指定模型对象方法
 *
 *在工厂类中会有两个以上的构造方法，一个是默认框架路径的模型对象构造方法，
 *还有一个是动态读取任意位置下的框架配置文件
 *
 * 2020年5月22日下午8:20:48
 *  com.shegx.model
 */
public class ConfigModelFactory {

	/**
	 * 通过资源文件构造对应的模型对象
	 * @param path  具体的资源路径
	 * @return
	 * @throws Exception 
	 */
	public static ConfidModel build(String path) throws Exception {
	//将文件转换为流
		InputStream is = ConfigModelFactory.class.getResourceAsStream(path);
		//定义一个saxreader对象
		SAXReader reader=new SAXReader();
		//将流转换为Dcumect对象
		Document doc = reader.read(is);
		//接下来把类容填充到configModel对象中(doc.asMxl--->config.xml)
		ConfidModel confidModel=new ConfidModel();
		Actionmodel actionModel=null;//定义ActionMOdel对象
		ForwardModel forwardModel=null;//定义Forwardmodel对象
		List<Element> actionEles = doc.selectNodes("/config/action");//从doc对象中取出
		for (Element action : actionEles) {//集合遍历取值
			actionModel=new Actionmodel();//实例化ActionModel对象
			//对ActionModel中的path设值
			actionModel.setPath(action.attributeValue("path"));
			//对ActionModel中的type设值
			actionModel.setType(action.attributeValue("type"));
			
			//给actionModel中放入forwardmodel对象
			//拿到forward标签类容
			List<Element> forwardEles = action.selectNodes("forward");
			for (Element forward : forwardEles) {
				forwardModel=new ForwardModel();
				forwardModel.setName(forward.attributeValue("name"));
				forwardModel.setPath(forward.attributeValue("path"));
				//redirect属性是boolean类型(只有xml中填写了false，它才代表转发)
				forwardModel.setRedirect("false".equals(forward.attributeValue("redirect")));
				//将赋值好的forwardModel对象，压到ActionModel集合
				actionModel.push(forwardModel);
			}
			//将赋值好的actionmodel对象，压到confidmodel集合
			confidModel.push(actionModel);
		}
		
		
		return confidModel;
	}
	
public static ConfidModel build() throws Exception {
		
		return build("/config.xml");
	}
	

        public static void main(String[] args) throws Exception {
			//定义一个configmodel对象，数据从ConfigModelFactory类中的build（）获取数据
        	ConfidModel model = ConfigModelFactory.build();
        	//需求：获取loginAction所在属性的type
        	Actionmodel actionmodel = model.pop("/loginAction");
        	System.out.println(actionmodel.getType());
        	//需求：获取/loginAction下success结果码对应的页面/main.jsp
        	ForwardModel forward = actionmodel.pop("success");
        	System.out.println(forward.getPath());
        	
		}	
	
}

结果·：

总结

XML建模使XML解析变得高效，简单，提高了代码的复用性