最新在看xwork的源代码,XmlConfigurationProvider这个类，用来实现解析xwork.xml配置文件。该类使用了有向图这种数据结构，来判断是否存在<include>元素的循环包含。
有向图的实现如下：
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
public final class DirectedGraph<T> implements Iterable<T>
{
private final Map<T, Set<T>> mGraph = new HashMap<T, Set<T>>();
/**
* Adds a new node to the graph. If the node already exists, this function is a no-op.
*
* @param node
* The node to add.
* @return Whether or not the node was added.
*/
public boolean addNode(T node) {
/* If the node already exists, don't do anything. */
if (mGraph.containsKey(node))
return false;
/* Otherwise, add the node with an empty set of outgoing edges. */
mGraph.put(node, new HashSet<T>());
return true;
}
/**
* Given a start node, and a destination, adds an arc from the start node to the destination. If an arc already exists, this operation is a no-op.
* If either endpoint does not exist in the graph, throws a NoSuchElementException.
*
* @param start
* The start node.
* @param dest
* The destination node.
* @throws NoSuchElementException
* If either the start or destination nodes do not exist.
*/
public void addEdge(T start, T dest) {
/* Confirm both endpoints exist. */
if (!mGraph.containsKey(start)) {
throw new NoSuchElementException("The start node does not exist in the graph.");
} else if (!mGraph.containsKey(dest)) {
throw new NoSuchElementException("The destination node does not exist in the graph.");
}
/* Add the edge. */
mGraph.get(start).add(dest);
}
/**
* Removes the edge from start to dest from the graph. If the edge does not exist, this operation is a no-op. If either endpoint does not exist,
* this throws a NoSuchElementException.
*
* @param start
* The start node.
* @param dest
* The destination node.
* @throws NoSuchElementException
* If either node is not in the graph.
*/
public void removeEdge(T start, T dest) {
/* Confirm both endpoints exist. */
if (!mGraph.containsKey(start)) {
throw new NoSuchElementException("The start node does not exist in the graph.");
} else if (!mGraph.containsKey(dest)) {
throw new NoSuchElementException("The destination node does not exist in the graph.");
}
mGraph.get(start).remove(dest);
}
/**
* Given two nodes in the graph, returns whether there is an edge from the first node to the second node. If either node does not exist in the
* graph, throws a NoSuchElementException.
*
* @param start
* The start node.
* @param end
* The destination node.
* @return Whether there is an edge from start to end.
* @throws NoSuchElementException
* If either endpoint does not exist.
*/
public boolean edgeExists(T start, T end) {
/* Confirm both endpoints exist. */
if (!mGraph.containsKey(start)) {
throw new NoSuchElementException("The start node does not exist in the graph.");
} else if (!mGraph.containsKey(end)) {
throw new NoSuchElementException("The end node does not exist in the graph.");
}
return mGraph.get(start).contains(end);
}
/**
* Given a node in the graph, returns an immutable view of the edges leaving that node as a set of endpoints.
*
* @param node
* The node whose edges should be queried.
* @return An immutable view of the edges leaving that node.
* @throws NoSuchElementException
* If the node does not exist.
*/
public Set<T> edgesFrom(T node) {
/* Check that the node exists. */
Set<T> arcs = mGraph.get(node);
if (arcs == null)
throw new NoSuchElementException("Source node does not exist.");
return Collections.unmodifiableSet(arcs);
}
/**
* Returns an iterator that can traverse the nodes in the graph.
*
* @return An iterator that traverses the nodes in the graph.
*/
public Iterator<T> iterator() {
return mGraph.keySet().iterator();
}
/**
* Returns the number of nodes in the graph.
*
* @return The number of nodes in the graph.
*/
public int size() {
return mGraph.size();
}
/**
* Returns whether the graph is empty.
*
* @return Whether the graph is empty.
*/
public boolean isEmpty() {
return mGraph.isEmpty();
}
}
通过上述源码发现：xwork框架采用的是有向图的邻接表方法进行存储的。
xwork使用CycleDetector用来判断有向图是否存在循环，实现如下：
public class CycleDetector<T>
{
private static final String marked = "marked";
private static final String complete = "complete";
private DirectedGraph<T> graph;
private Map<T, String> marks;
private List<T> verticesInCycles;
public CycleDetector(DirectedGraph<T> graph)
{
this.graph = graph;
marks = new HashMap<T, String>();
verticesInCycles = new ArrayList<T>();
}
public boolean containsCycle()
{
for (T v : graph)
{
// 如果v正在遍历或者遍历完成,不需要进入mark(),因为mark是一个递归调用，使用的是深度优先搜索算法;
// 这是为了保证1个顶点只会遍历一次
if (!marks.containsKey(v))
{
if (mark(v))
{
// return true;
}
}
}
return !verticesInCycles.isEmpty();
}
//DFS算法,遍历顶点vertex
// @return 当前顶点是否在环上
private boolean mark(T vertex)
{
List<T> localCycles = new ArrayList<T>();
// 当前顶点vertex,遍历开始
marks.put(vertex, marked);
for (T u : graph.edgesFrom(vertex))
{
// u的遍历还没有结束,说明存在u->vertex的通路,也存在vertex->u的通路,形成了循环
if (marks.containsKey(u) && marks.get(u).equals(marked))
{
localCycles.add(vertex);
// return true;
}
else if (!marks.containsKey(u))
{
if (mark(u))
{
localCycles.add(vertex);
// return true;
}
}
}
// 当前顶点vertex,遍历完成
marks.put(vertex, complete);
verticesInCycles.addAll(localCycles);
return !localCycles.isEmpty();
}
public List<T> getVerticesInCycles()
{
return verticesInCycles;
}
}