neo4j的demo数据

gistfile1.java

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Path;
import org.neo4j.graphdb.PropertyContainer;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.index.Index;
import org.neo4j.graphdb.index.IndexManager;
import org.neo4j.graphdb.index.RelationshipIndex;
import org.neo4j.graphdb.traversal.Evaluators;
import org.neo4j.graphdb.traversal.TraversalDescription;
import org.neo4j.graphdb.traversal.Traverser;
import org.neo4j.kernel.Traversal;
import org.neo4j.rest.graphdb.RestGraphDatabase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Example {
	private static Logger logger = LoggerFactory.getLogger(Example.class);

	private static final String DB_PATH = "http://localhost:7474/db/data";
	private static final String NAME_KEY = "name";
	private static final String AGE_KEY = "age";
	private static final String GENDER_KEY = "gender";
	private static final String PROFESSION_KEY = "profession";
	private static final String DESCRIPTION_KEY = "description";
	private static GraphDatabaseService graphDb;
	private static Index<Node> userIndex;
	private static Index<Node> orgIndex;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		logger.debug("连接数据库 ...");
		graphDb = new RestGraphDatabase(DB_PATH);
		userIndex = graphDb.index().forNodes("UserIndex");
		orgIndex = graphDb.index().forNodes("OrgIndex");

		// 初始化数据
		cleanDb(1000);
		initDb();

		Node foundUser = userIndex.get(NAME_KEY, "老何").getSingle();
		// 列出他认识的人及可能认识的人
		findFriends(foundUser);
		logger.debug("shutdown...");
		shutdown();
	}

	public static void initDb() {
		// 创建主角用户
		logger.debug("创建主角用户");
		Node xiangyu = createIndexUser("佟湘玉", 30, "女", "掌柜");
		Node zhantang = createIndexUser("白展堂", 28, "男", "跑堂");
		Node xiaoguo = createIndexUser("郭芙蓉", 20, "女", "杂役");
		Node xiucai = createIndexUser("吕轻侯", 21, "男", "账房");
		Node wushuang = createIndexUser("祝无双", 19, "女", "捕快");
		Node dazui = createIndexUser("李大嘴", 25, "男", "厨子");
		Node xiaobei = createIndexUser("莫小贝", 8, "女", "掌门");

		// 建立主角关系
		logger.debug("建立主角关系");
		xiangyu.createRelationshipTo(zhantang, Rel.认识);
		xiangyu.createRelationshipTo(xiaoguo, Rel.认识);
		xiangyu.createRelationshipTo(xiucai, Rel.认识);
		xiangyu.createRelationshipTo(wushuang, Rel.认识);
		xiangyu.createRelationshipTo(dazui, Rel.认识);
		xiangyu.createRelationshipTo(xiaobei, Rel.认识);

		zhantang.createRelationshipTo(xiangyu, Rel.认识);
		zhantang.createRelationshipTo(xiaoguo, Rel.认识);
		zhantang.createRelationshipTo(xiucai, Rel.认识);
		zhantang.createRelationshipTo(wushuang, Rel.认识);
		zhantang.createRelationshipTo(dazui, Rel.认识);
		zhantang.createRelationshipTo(xiaobei, Rel.认识);

		xiucai.createRelationshipTo(zhantang, Rel.认识);
		xiucai.createRelationshipTo(xiaoguo, Rel.认识);
		xiucai.createRelationshipTo(xiangyu, Rel.认识);
		xiucai.createRelationshipTo(wushuang, Rel.认识);
		xiucai.createRelationshipTo(dazui, Rel.认识);
		xiucai.createRelationshipTo(xiaobei, Rel.认识);

		xiaoguo.createRelationshipTo(zhantang, Rel.认识);
		xiaoguo.createRelationshipTo(xiangyu, Rel.认识);
		xiaoguo.createRelationshipTo(xiucai, Rel.认识);
		xiaoguo.createRelationshipTo(wushuang, Rel.认识);
		xiaoguo.createRelationshipTo(dazui, Rel.认识);
		xiaoguo.createRelationshipTo(xiaobei, Rel.认识);

		wushuang.createRelationshipTo(zhantang, Rel.认识);
		wushuang.createRelationshipTo(xiaoguo, Rel.认识);
		wushuang.createRelationshipTo(xiucai, Rel.认识);
		wushuang.createRelationshipTo(xiangyu, Rel.认识);
		wushuang.createRelationshipTo(dazui, Rel.认识);
		wushuang.createRelationshipTo(xiaobei, Rel.认识);

		dazui.createRelationshipTo(zhantang, Rel.认识);
		dazui.createRelationshipTo(xiaoguo, Rel.认识);
		dazui.createRelationshipTo(xiucai, Rel.认识);
		dazui.createRelationshipTo(wushuang, Rel.认识);
		dazui.createRelationshipTo(xiangyu, Rel.认识);
		dazui.createRelationshipTo(xiaobei, Rel.认识);

		xiaobei.createRelationshipTo(zhantang, Rel.认识);
		xiaobei.createRelationshipTo(xiaoguo, Rel.认识);
		xiaobei.createRelationshipTo(xiucai, Rel.认识);
		xiaobei.createRelationshipTo(wushuang, Rel.认识);
		xiaobei.createRelationshipTo(dazui, Rel.认识);
		xiaobei.createRelationshipTo(xiangyu, Rel.认识);

		// 创建配角用户
		logger.debug("创建配角用户");
		Node laoxing = createIndexUser("邢捕头", 35, "男", "捕头");
		Node xiaoliu = createIndexUser("燕小六", 18, "男", "捕头");
		Node laoye = createIndexUser("七舅姥爷", 68, "男", "");
		Node huilan = createIndexUser("杨蕙兰", 23, "女", "");
		Node duzijun = createIndexUser("杜子俊", 42, "男", "财主");
		Node jiwuming = createIndexUser("姬无命", 30, "男", "盗贼");
		Node duanzhi = createIndexUser("断指轩辕", 56, "女", "");
		Node xiaoqing = createIndexUser("小青", 21, "女", "丫鬟");
		Node tongboda = createIndexUser("佟伯达", 58, "男", "掌柜");
		Node xiansheng = createIndexUser("朱先生", 56, "男", "先生");
		Node hanjuan = createIndexUser("韩娟", 29, "女", "掌门夫人");
		Node laohe = createIndexUser("老何", 52, "男", "掌门");

		// 建立配角关系
		logger.debug("建立配角关系");
		wushuang.createRelationshipTo(xiaoliu, Rel.认识);
		xiaoliu.createRelationshipTo(wushuang, Rel.认识);
		xiaoliu.createRelationshipTo(laoxing, Rel.认识);
		laoxing.createRelationshipTo(xiaoliu, Rel.认识);
		xiaoliu.createRelationshipTo(laoye, Rel.认识);
		laoye.createRelationshipTo(xiaoliu, Rel.认识);
		dazui.createRelationshipTo(huilan, Rel.认识);
		huilan.createRelationshipTo(dazui, Rel.认识);
		huilan.createRelationshipTo(duzijun, Rel.认识);
		duzijun.createRelationshipTo(huilan, Rel.认识);
		zhantang.createRelationshipTo(jiwuming, Rel.认识);
		jiwuming.createRelationshipTo(zhantang, Rel.认识);
		dazui.createRelationshipTo(duanzhi, Rel.认识);
		duanzhi.createRelationshipTo(dazui, Rel.认识);
		xiaoguo.createRelationshipTo(xiaoqing, Rel.认识);
		xiaoqing.createRelationshipTo(xiaoguo, Rel.认识);
		xiangyu.createRelationshipTo(tongboda, Rel.认识);
		tongboda.createRelationshipTo(xiangyu, Rel.认识);
		xiaobei.createRelationshipTo(xiansheng, Rel.认识);
		xiansheng.createRelationshipTo(xiaobei, Rel.认识);
		xiangyu.createRelationshipTo(hanjuan, Rel.认识);
		hanjuan.createRelationshipTo(xiangyu, Rel.认识);
		hanjuan.createRelationshipTo(laohe, Rel.认识);
		laohe.createRelationshipTo(hanjuan, Rel.认识);

		// 创建单位(公司/组织/机构)
		logger.debug("创建单位");
		Node tongfu = createIndexOrg("同福客栈", "");
		Node hengshan = createIndexOrg("衡山派", "");
		Node qixiazhen = createIndexOrg("七侠镇衙门", "");
		Node shibalipu = createIndexOrg("十八里铺衙门", "");
		Node longmen = createIndexOrg("龙门镖局", "");
		Node baima = createIndexOrg("白马书院", "");
		Node kunlun = createIndexOrg("昆仑派", "");

		// 建立单位(公司/组织/机构)关系
		logger.debug("建立单位关系");
		tongfu.createRelationshipTo(xiangyu, Rel.雇佣);
		xiangyu.createRelationshipTo(tongfu, Rel.受雇);
		tongfu.createRelationshipTo(zhantang, Rel.雇佣);
		zhantang.createRelationshipTo(tongfu, Rel.受雇);
		tongfu.createRelationshipTo(xiaoguo, Rel.雇佣);
		xiaoguo.createRelationshipTo(tongfu, Rel.受雇);
		tongfu.createRelationshipTo(xiucai, Rel.雇佣);
		xiucai.createRelationshipTo(tongfu, Rel.受雇);
		tongfu.createRelationshipTo(dazui, Rel.雇佣);
		dazui.createRelationshipTo(tongfu, Rel.受雇);
		hengshan.createRelationshipTo(xiaobei, Rel.雇佣);
		xiaobei.createRelationshipTo(hengshan, Rel.受雇);
		qixiazhen.createRelationshipTo(xiaoliu, Rel.雇佣);
		xiaoliu.createRelationshipTo(qixiazhen, Rel.受雇);
		qixiazhen.createRelationshipTo(wushuang, Rel.雇佣);
		wushuang.createRelationshipTo(qixiazhen, Rel.受雇);
		shibalipu.createRelationshipTo(laoxing, Rel.雇佣);
		laoxing.createRelationshipTo(shibalipu, Rel.受雇);
		longmen.createRelationshipTo(tongboda, Rel.雇佣);
		tongboda.createRelationshipTo(longmen, Rel.受雇);
		baima.createRelationshipTo(xiansheng, Rel.雇佣);
		xiansheng.createRelationshipTo(baima, Rel.受雇);
		kunlun.createRelationshipTo(laohe, Rel.雇佣);
		laohe.createRelationshipTo(kunlun, Rel.受雇);
		kunlun.createRelationshipTo(hanjuan, Rel.雇佣);
		hanjuan.createRelationshipTo(kunlun, Rel.受雇);
	}

	private static Node createIndexUser(final String name, final int age, final String gender, final String profession) {
		Node node = graphDb.createNode();
		node.setProperty(NAME_KEY, name);
		node.setProperty(AGE_KEY, age);
		node.setProperty(GENDER_KEY, gender);
		node.setProperty(PROFESSION_KEY, profession);

		// 添加该记录的索引
		userIndex.add(node, NAME_KEY, name);
		userIndex.add(node, AGE_KEY, age);
		userIndex.add(node, GENDER_KEY, gender);
		userIndex.add(node, PROFESSION_KEY, profession);
		return node;
	}

	private static Node createIndexOrg(String name, String description) {
		Node node = graphDb.createNode();
		node.setProperty(NAME_KEY, name);
		node.setProperty(DESCRIPTION_KEY, description);
		// 添加该记录的索引
		orgIndex.add(node, NAME_KEY, name);
		orgIndex.add(node, DESCRIPTION_KEY, description);
		return node;
	}

	private static Traverser getFriends(final Node person) {
		TraversalDescription td = Traversal.description().breadthFirst().relationships(Rel.认识, Direction.OUTGOING)
				.evaluator(Evaluators.excludeStartPosition());
		return td.traverse(person);
	}

	private static void findFriends(Node node1) {
		int numberOfFriends = 0;
		String output = node1.getProperty(NAME_KEY) + "'s friends:\n";
		Traverser friendsTraverser = getFriends(node1);
		for (Path friendPath : friendsTraverser) {
			output += "At depth " + friendPath.length() + " => " + friendPath.endNode().getProperty(NAME_KEY) + "\n";
			logger.debug("==============a path:");
			for (Node n : friendPath.nodes()) {
				logger.debug(n.getProperty(NAME_KEY).toString());
			}
			numberOfFriends++;
		}
		output += "Number of friends found: " + numberOfFriends + "\n";

		logger.debug(output);
	}

	private static void shutdown() {
		graphDb.shutdown();
	}

	public static Map<String, Object> cleanDb(long maxNodesToDelete) {
		Map<String, Object> result = new HashMap<String, Object>();
		Transaction tx = graphDb.beginTx();
		try {
			clearIndex(result);
			removeNodes(result, maxNodesToDelete);
			tx.success();
		} finally {
			tx.finish();
		}
		return result;
	}

	private static void removeNodes(Map<String, Object> result, long maxNodesToDelete) {
		Node refNode = graphDb.getReferenceNode();
		long nodes = 0, relationships = 0;
		for (Node node : graphDb.getAllNodes()) {
			for (Relationship rel : node.getRelationships()) {
				rel.delete();
				relationships++;
			}
			if (!refNode.equals(node)) {
				node.delete();
				nodes++;
			}
			if (nodes >= maxNodesToDelete)
				break;
		}
		result.put("maxNodesToDelete", maxNodesToDelete);
		result.put("nodes", nodes);
		result.put("relationships", relationships);

	}

	private static void clearIndex(Map<String, Object> result) {
		IndexManager indexManager = graphDb.index();
		result.put("node-indexes", Arrays.asList(indexManager.nodeIndexNames()));
		result.put("relationship-indexes", Arrays.asList(indexManager.relationshipIndexNames()));
		try {
			for (String ix : indexManager.nodeIndexNames()) {
				final Index<Node> index = indexManager.forNodes(ix);
				getMutableIndex(index).delete();
			}
			for (String ix : indexManager.relationshipIndexNames()) {
				final RelationshipIndex index = indexManager.forRelationships(ix);
				getMutableIndex(index).delete();
			}
		} catch (UnsupportedOperationException uoe) {
			throw new RuntimeException(
					"Implementation detail assumption failed for cleaning readonly indexes, please make sure that the version of this extension and the Neo4j server align");
		}
	}

	private static <T extends PropertyContainer> Index<T> getMutableIndex(Index<T> index) {
		final Class<? extends Index> indexClass = index.getClass();
		if (indexClass.getName().endsWith("ReadOnlyIndexToIndexAdapter")) {
			try {
				final Field delegateIndexField = indexClass.getDeclaredField("delegate");
				delegateIndexField.setAccessible(true);
				return (Index<T>) delegateIndexField.get(index);
			} catch (Exception e) {
				throw new UnsupportedOperationException(e);
			}
		} else {
			return index;
		}
	}

}