循环调用检测

package com.wmp.test2;


import java.util.ArrayList;
import java.util.List;

/**
 * A->B, B->C, A->D, C->E, C->A
 * 查找循环调研
 */
public class InvokeChain {


    public static void main(String[] args) {

        //构建结构关系
        Node A = new Node("A");
        Node B = new Node("B");
        Node C = new Node("C");
        Node D = new Node("D");
        Node E = new Node("E");
        Node F = new Node("F");

        B.setParent(A);
        C.setParent(B);
        D.setParent(A);
        E.setParent(C);
        A.setParent(C);
        F.setParent(D);

    }

    private static final class Node {

        private String v;
        private Node parent;

        public Node(String v) {
            this.v = v;
        }

        public String getV() {
            return v;
        }

        public void setV(String v) {
            this.v = v;
        }

        public Node getParent() {
            return parent;
        }

        //设置父节点时检测重复调用
        public boolean setParent(Node parent) {

            boolean repeat = isRepeat(parent);
            if (repeat) {
                List<Node> list = new ArrayList<>();
                list.add(this);
                Node cur = parent;
                while(cur != null) {
                    list.add(cur);
                    cur = cur.parent;
                }
                for (int i = list.size() - 1; i >= 0; i--) {
                    System.out.print(list.get(i).getV());
                    if (i != 0) {
                        System.out.print(" -> ");
                    }
                }
            } else {
                this.parent = parent;
            }

            return !repeat;
        }

        //检测重复
        public boolean isRepeat(Node parent) {
            Node target = parent;
            while(target != null) {

                if (v.equals(target.getV())) {
                    System.out.println("Invoke repeat!");
                    return true;
                }
                target = target.parent;
            }
            return false;
        }

    }
}

执行结果：

Invoke repeat!
A -> B -> C -> A