[Java知识库]XML建模

J2EE

前言：

XML的解析，可以将我们需要的资源从XML文件中读取出来再使用。如果不建模就要每次都去读取

资源，会带来没必要的麻烦。建模的好处就是只需要读取一遍资源，将其变成java对象来使用，提

高了代码的复用性，性能，关于XML的读取过程只需一次。这里采用了java的23种设计模式中的工

厂模式。

目录

J2EE

1、什么是建模？

2、建模分析

核心思想：面对对象思想创建模型

①分析xml文件结构

②模型创建

案例一

案例一各类关系之间关系结构图解：

实例二

?总结：java对象构建成的模型是XML结构的映射

1、什么是建模？

个人理解：建模就是使用java创建的类构成的关系结构即模型映射出XML文件结构，建模之后可以

将XML文件中的资源内容通过工厂模式生产之后变成我们的java对象来操作使用。

理解案例：java创建出飞机模型（类与类之间的关系和结构），工厂根据模型来建造真正的飞机

（一个具体的具有XML资源内容的对象）。

2、建模分析

核心思想：面对对象思想创建模型

理清思路最重要：

①分析xml文件结构

先看一下xml文件，通过它的结构能相处哪些类？类与类之间的关系是什么？来实现这个结构

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE config>

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

config：根元素标签 （无属性，有行为）

action：元素标签 属性：type path （有属性，有行为）

forward：元素标签 属性：path redirect name （有属性，无行为）

注：forward无属性是应为本身是一个自闭标签，不会再有子元素。

可以将我们的标签看做每一个对象，自闭标签不会有子元素标签，所有无行为，也就是对应的类中

不会有相应的添加子元素对象的方法。我们把上述元素标签看做类，再看一下代码：

②模型创建

案例一

ForwardModel类：

package com.zwf.model;

/**
 * ForwardModel标签元素实体类
 * @author zjjt
 *
 */
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 ForwardModel(String name, String path, boolean redirect) {
		super();
		this.name = name;
		this.path = path;
		this.redirect = redirect;
	}
	
	public ForwardModel() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "ForwardModel [name=" + name + ", path=" + path + ", redirect=" + redirect + "]";
	}
}

ActionModel类

package com.zwf.model;

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

/**
 * Action标签元素实体类
 * @author zjjt
 *
 */
public class ActionModel {
	private String type;
	private String path;
	//子元素标签(ForwardModel)对象存储容器
	private Map<String, ForwardModel> m=new HashMap<String, ForwardModel>();
	
	/**
	 * 添加forward标签对象  
	 * @param fm forward标签对象
	 */
	public void push(ForwardModel fm) {
		m.put(fm.getName(), fm);
	}
	
	/**
	 * 通过name拿ForwardModel对象
	 * @param name forward标签的name属性
	 * @return
	 */
	public ForwardModel pop(String name) {
		return m.get(name);
	}
	
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getPath() {
		return path;
	}
	public void setPath(String path) {
		this.path = path;
	}
	public Map<String, ForwardModel> getM() {
		return m;
	}
	public void setM(Map<String, ForwardModel> m) {
		this.m = m;
	}
	public ActionModel(String type, String path, Map<String, ForwardModel> m) {
		super();
		this.type = type;
		this.path = path;
		this.m = m;
	}
	
	public ActionModel() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "ActionModel [type=" + type + ", path=" + path + ", m=" + m + "]";
	}
}

ConfigModel类：

package com.zwf.model;

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

/**
 * 根标签元素实体类
 * @author zjjt
 *
 */
public class ConfigModel {
	//子元素标签(Action)的存储容器
	private Map<String, ActionModel> m=new HashMap<String, ActionModel>();
	
	/**
	 * 添加ActionModel元素对象
	 * @param am 要添加的action标签对象
	 */
	public void push(ActionModel am) {
		m.put(am.getPath(), am);
	}
	
	/**
	 * 通过path属性获得Action元素
	 * @param name action的path属性
	 * @return
	 */
	public ActionModel pop(String name) {
		return m.get(name);
	}
}

ConfigModelFactory类：

package com.zwf.model;

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

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

/**
 * 工厂类：创建解析了xml文件后的相应对象
 * @author zjjt
 *
 */
public class ConfigModelFactory {
	public static ConfigModel build() throws Exception {
		return build("config.xml");
	}
	public static ConfigModel build(String repath) throws Exception {
		//实例化Config元素
		ConfigModel cm=new ConfigModel();
		//获得XML文件输入流
		InputStream in = ConfigModelFactory.class.getResourceAsStream(repath);
		//获取读取工具对象
		SAXReader sr=new SAXReader();
		//获取doc对象
		Document doc = sr.read(in);
		//拿到根目录下的所有action标签对象
		List<Element> actionEles = doc.selectNodes("/config/action");
		//遍历
		for (Element acEle : actionEles) {
			//获得action标签path、type属性值
			String path = acEle.attributeValue("path");
			String type = acEle.attributeValue("type");
			//action对象存储forward标签的容器
			Map<String, ForwardModel> m=new HashMap<String, ForwardModel>();
			//获得该action元素下的所有forward标签
			List<Element> forwardEles = acEle.selectNodes("forward");
			//遍历
			for (Element fwEle : forwardEles) {
				//获得forward标签name,path,redirect属性值
				String name = fwEle.attributeValue("name");
				String path2 = fwEle.attributeValue("path");
				String redirect = fwEle.attributeValue("redirect");
				ForwardModel fm=new ForwardModel(name,path2,!"false".equals(redirect));
				//添加forward标签对象到action对象的forward标签容器中
				m.put(name, fm);
			}
			ActionModel am=new ActionModel(type,path,m);
			//将action对象添加到config对象的存储容器中
			cm.push(am);
		}
		return cm;
	}
	
	public static void main(String[] args) throws Exception {
		//通过工厂创建解析了config.xml文件后获得的config对象
		ConfigModel con = ConfigModelFactory.build();
		
		//通过action标签的path属性拿到对应的action对象
		ActionModel am = con.pop("/regAction");
		
		System.out.println(am);
		
		//通过forward标签的name属性拿到对应的forward对象
		ForwardModel fm = am.pop("failed");
		
		System.out.println(fm);	
	}
}

父元素包含子元素然后子元素作为下一层的父元素往下包含的一个关系。这些类与类之间的关系和

我们的xml结构非常相似。

案例一各类关系之间关系结构图解：

这些类构成了xml模型，然后通过工厂类生产出具有XML文件资源的一个具体对象。

实例二

再来看一个实例：

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
  <servlet>
  	<servlet-name>jrebelServlet</servlet-name>
  	<servlet-class>com.zking.xml.JrebelServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>jrebelServlet</servlet-name>
  	<url-pattern>/jrebelServlet</url-pattern>
  </servlet-mapping>
  
  <servlet>
  	<servlet-name>jrebelServlet2</servlet-name>
  	<servlet-class>com.zking.xml.JrebelServlet2</servlet-class>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>jrebelServlet2</servlet-name>
  	<url-pattern>/jrebelServlet2</url-pattern>
  	<url-pattern>/jrebelServlet3</url-pattern>
  </servlet-mapping>
</web-app>

java代码：

web-app对应的实体类：

package com.zwf.xmlmodel;

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

/**
*web-app标签实体类
**/
public class WebAppModle {
    //存储容器
	private Map<String, WebAppModle> m=new HashMap<String, WebAppModle>();;	
	
	public Map<String, WebAppModle> getM() {
		return m;
	}


	public void setM(Map<String, WebAppModle> m) {
		this.m = m;
	}

	/**
	 * 压栈
	 * @param w 添加的对象
	 */
	public void push(WebAppModle w) {
		if(w instanceof ServletModel) {
			m.put(((ServletModel) w).getName(), (ServletModel) w);
		}else if(w instanceof ServletMappingModel) {
			m.put(((ServletMappingModel) w).getPattern(), (ServletMappingModel) w);
		}
	}
	
	/**
	 * 弹栈
	 * @param name 根据名称获取对象
	 * @return 对应对象
	 */
	public WebAppModle pop(String name) {
		return m.get(name);
	}
}

servlet对应的实体类：

package com.zwf.xmlmodel;

/**
* servlet标签实体类
**/
public class ServletModel extends WebAppModle{
	private String name;
	private String clazz;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getClazz() {
		return clazz;
	}
	public void setClazz(String clazz) {
		this.clazz = clazz;
	}
	
	public ServletModel() {
		
	}
	public ServletModel(String name, String clazz) {
		super();
		this.name = name;
		this.clazz = clazz;
	}
	@Override
	public String toString() {
		return "Servlet [name=" + name + ", clazz=" + clazz + "]";
	}	
}

servlet-mapping对应的实体类：

package com.zwf.xmlmodel;

/**
* serlet-mapping实体类
**/
public class ServletMappingModel extends WebAppModle{
	private String name;
	private String pattern;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPattern() {
		return pattern;
	}
	public void setPattern(String pattern) {
		this.pattern = pattern;
	}
	public ServletMappingModel(String name, String pattern) {
		super();
		this.name = name;
		this.pattern = pattern;
	}
	@Override
	public String toString() {
		return "ServletMappingModel [name=" + name + ", pattern=" + pattern + "]";
	}
	
	public ServletMappingModel() {
		// TODO Auto-generated constructor stub
	}
}

工厂类：

package com.zwf.xmlmodel;

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

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

public class WebAppModleFactory {
	/**
	 * 工厂生产口
	 * @return 解析web.xml后的WebAPPModel对象
	 * @throws Exception
	 */
	public static WebAppModle build() throws Exception {
		return build("web.xml");
	}
	
    /**
	 * 工厂的创建方法
	 * @param path xml文件名
	 * @return 解析了xml文件的WebAppModel对象
	 * @throws Exception
	 */
	public static WebAppModle build(String path) throws Exception {
        //获取webAppModel对象
		WebAppModle w=new WebAppModle();
        //获得对应xml文件输入流
		InputStream in = WebAppModleFactory.class.getResourceAsStream(path);
		SAXReader sr=new SAXReader();
		Document doc = sr.read(in);
        //读取所有的servlet标签元素
		List<Element> servletEles = doc.selectNodes("/web-app/servlet");
		for (Element servletEle : servletEles) {
			String name=servletEle.selectSingleNode("servlet-name").getText();
			String clazz=servletEle.selectSingleNode("servlet-class").getText();
			WebAppModle m=new ServletModel(name,clazz);
            //将servlet对象添加到WebApModel的存储容器中
			w.push(m);
		}
        //读取所有的servlet-mapping标签元素
		List<Element> mappingEles = doc.selectNodes("/web-app/servlet-mapping");
		for (Element mappingEle : mappingEles) {
			String name=mappingEle.selectSingleNode("servlet-name").getText();
			String pattern=mappingEle.selectSingleNode("url-pattern").getText();
			WebAppModle m=new ServletMappingModel(name, pattern);
            //将servlet-mapping对象添加到WebApModel的存储容器中
			w.push(m);
		}
		return w;
	}
	
	public static void main(String[] args) throws Exception {
		WebAppModleFactory.build();
	}	
}

这个案例，我是用继承实现了，WebAppModle对象中的容器即能装servletModel对象也可以装

serletMappingModel对象来完成该Xml文件的模型。我们的模型并不是定死的，根据XML的结构来

创建我们的模型，然后通过工厂生产。这里使用了map集合来作为父元素存储子元素的存储元素，

key是子元素标签的唯一属性，value是子元素标签对象本身。

?总结：java对象构建成的模型是XML结构的映射

建模的概念就是用java面对对象的思想创建我们的java对象来实现和xml文件结构相似的一个模

型，类与类之间的关系结构（模型结构）就反应出xml文件的结果。再通过工厂模式生产解析了xml

文件后的一个具体对象来。有了模型，解析文件这一个过程只需要执行一次，之后的操作可以使用

我们定义的对象进行操作。