XML建模

XML建模

1.什么是XML建模

建模其实就是将指定的xml字符串当作对象来操作
如果说当对一个指定的xml格式字符串完成了建模操作，那么就只需要调用指定的方法就可以完成预定的字符串获取。
拿下面这些标签比例

程序员张三需要通过 /LoginAction 获取 type=test.LoginAction串。
然后操作步骤是：

1、加载资源文件xxx.class.getResourceAsSteam('config.xml');
2、通过xpath解析获取到所有的action元素标签列表。
（xpath解析前面的博客讲过，传送门看下面）
3、遍历，如果action标签的path属性等于/loginAction，那么就是我们的action标签。
4、找到的action，就以获取到对应的action标签的type属性

那么根据以上步骤，如果是程序员李四需要通过 /regAction 获取 type=test.RegAction串。只是在第三步中把/loginAction替换为/regAction。

1、遍历，如果action标签的path属性等于/loginAction，那么就是我们的action标签。
2. 替换为
3、遍历，如果action标签的path属性等于/regAction，那么就是我们的action标签。

如果是程序员王五需要通过 /regAction 获取 type=test.RegAction串。只是在第三步中把/loginAction替换为/regAction。

2.建模的核心思想

xml建模的核心思想就是利用java面对对象的特性，用操作对象的方式来操作xml。

3.xml建模的代码完成

拿下面xml文件来建模比喻

<?xml version="1.0" encoding="UTF-8"?>
	<!--
		config标签:可以包含0~N个action标签
	-->
<config>
	<!--
		action标签:可以饱含0~N个forward标签
		path:以/开头的字符串,并且值必须唯一 非空
		type:字符串,非空
	-->
	<action path="/regAction" type="demo.Student">
		<!--
			forward标签:没有子标签; 
			name:字符串,同一action标签下的forward标签name值不能相同 ;
			path:以/开头的字符串
			redirect:只能是false|true,允许空,默认值为false
		-->
		<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。
一个类由两部分（属性和方法）组成，那我们就通过这两部分对这三个对象进行分析：

Config对象——>Config类
属性：没有属性
行为：新增Action对象的行为，通过action path属性查找Action对象的行为。
config标签:可以包含0~N个action标签

Action类
属性：path属性、type属性
行为：新增Forward对象的行为，通过Forward对象name属性查找对应的Forward对象的行为
action标签:可以饱含0~N个forward标签
path:以/开头的字符串,并且值必须唯一 非空
type:字符串,非空

Forward类
属性：name属性、path属性、redirect属性
行为：没有
forward标签:没有子标签; 
name:字符串,同一action标签下的forward标签name值不能相同 ;
path:以/开头的字符串
redirect:只能是false|true,允许空,默认值为false

分析好之后，开始准备代码。
注意顺序由里到外，由forward写到config。
ActionModel代码核心思路

public class ActionModel {
	private String path;
	private String type;
	private Map<String, ForwardModel> forwardModels=new HashMap<String, ForwardModel>();
	
	
	public void put(ForwardModel forwardModel) {
		//传递过来准备添加的forwardModel的name值不允许重复
		if (forwardModels.containsKey(forwardModel.getName())) {
			 //提醒用户键位重复停止添加
			throw new RuntimeException("键位["+forwardModel.getName()+"]重复了");
		}
		forwardModels.put(forwardModel.getName(), forwardModel);
	}
	/**
	 * 根据键位取值
	 * @param name
	 * @return
	 */
	public ForwardModel get(String name) {
		if (!forwardModels.containsKey(name)) {
			throw new RuntimeException("键位["+name+"]不存在");
		}
		return forwardModels.get(name);
	}
	
	
	
	
	
	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;
	}

}

其次就是ConfigModel代码思路

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

public class ConfigModel {
	private Map<String, ActionModel> actionModels=new HashMap<String, ActionModel>();
	
	
	public void put(ActionModel actionModel) {
		if (actionModels.containsKey(actionModel.getPath())) {
			throw new RuntimeException("键位["+actionModel.getPath()+"]重复了");
		}
		actionModels.put(actionModel.getPath(), actionModel);
	}
	
	public ActionModel get(String path) {
		if (!actionModels.containsKey(path)) {
			throw new RuntimeException("键位["+path+"]不存在");
		}
		return actionModels.get(path);
		
	}
}

ForwardModel代码核心思路

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;
	}
	public void setRedirect(String redirect) {
		this.redirect = Boolean.parseBoolean(redirect);
	}
	
	@Override
	public String toString() {
		return "ForwardModel [name=" + name + ", path=" + path + ", redirect=" + redirect + "]";
	}
}

三个都完成之后，就开始撞到ConfigModel里面去，建出ConfigModelFactory工厂类。

4.Factory工厂类

代码如下

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;

/**
 * 从对应的xml文件中读取所有的节点信息，然后保存在java对象中
 * @author 小华华
 *
 */
public class ConfigModelFactory {
	//声明一个默认路径
	private static String PATH="/config.xml";
	
	/**
	 * 0.该工厂类创建configModel的方法应该在任何情况下被调用
	 * 1.读取一个配置文件
	 */
	private ConfigModelFactory() {

	}
	/**
	 * 创建配置文件创建configModel对象
	 * @param path
	 * @return
	 * @throws DocumentException
	 */
	public static ConfigModel createConfigModel(String path) throws DocumentException {
		InputStream is=null;
		if (null==path) {
			is=ConfigModelFactory.class.getResourceAsStream(PATH);
		}else {
			is=ConfigModelFactory.class.getResourceAsStream(path);
		}
	//将文件转换为docment
		SAXReader sax=new SAXReader();
		Document docment = sax.read(is);
	//创建configModel
		ConfigModel configModel=new ConfigModel();
		//读取所有action节点
		List<Element> actionElement = docment.selectNodes("config/action");
		for (Element acEle : actionElement) {
			ActionModel actionModel=new ActionModel();
			String actionPath = acEle.attributeValue("path");
			String actionType = acEle.attributeValue("type");
		//给actionModel赋值
			actionModel.setPath(actionPath);
			actionModel.setType(actionType);
		//得到当前action节点的所有forward节点
			List<Element> forwardElement= acEle.selectNodes("forward");
		for (Element forEle : forwardElement) {
			ForwardModel forwardModel=new ForwardModel();
			String forwardName = forEle.attributeValue("name");
			String forwardPath = forEle.attributeValue("path");
			String redirect = forEle.attributeValue("redirect");
		forwardModel.setName(forwardName);
		forwardModel.setPath(forwardPath);
		forwardModel.setRedirect(redirect);
		actionModel.put(forwardModel);
		}
		configModel.put(actionModel);
		}
	return configModel;
	}
}

使用xml建模工厂大大的减少了代码的重复性。从而写起代码更轻松！